{
    "info": {
        "author": "Arjun G. Menon",
        "author_email": "contact@arjungmenon.com",
        "bugtrack_url": null,
        "classifiers": [
            "Environment :: Console",
            "Environment :: Web Environment",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: Apache Software License",
            "Operating System :: OS Independent",
            "Programming Language :: Python :: 2",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3.2",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
            "Programming Language :: Python :: 3.5",
            "Programming Language :: Python :: Implementation :: CPython",
            "Programming Language :: Python :: Implementation :: PyPy",
            "Topic :: Internet :: WWW/HTTP",
            "Topic :: Software Development :: Libraries :: Python Modules",
            "Topic :: Text Processing",
            "Topic :: Text Processing :: Markup :: HTML"
        ],
        "description": "pypage |build| |pypi| |docs|\n============================\n\npypage is a document template engine for Python programmers with a\nshort learning curve.\n\n**Why use pypage?**\n\n-  Easy to pick up. Syntax similar to Python's.\n-  You need an eval-based template engine.\n\npypage supports Python 3.x and 2.7, and has been `tested <https://travis-ci.org/arjun-menon/pypage>`_\n(using `test_cmd <https://github.com/arjun-menon/test_cmd>`_) on CPython and PyPy.\n\n**What does it look like?**\n\n.. code:: html\n\n    <ul id=\"users\">\n      {% for user in users %}\n        <li>\n          <a href=\"mailto: {{ html_ascii( user.email ) }}\">{{ user.name }}</a>\n        </li>\n      {% endfor %}\n    </ul>\n\n**Installation**\n\nYou can `install <https://docs.python.org/3/installing/>`_ pypage easily with `pip <https://pip.pypa.io/en/stable/>`_:\n\n.. code::\n\n    pip install pypage\n\nTry running ``pypage -h`` to see the command-line options available.\n\n.. contents:: **Table of Contents**\n\n\nEmbedding Code\n--------------\n\nIn order to embed code in a document, you wrap Python code with ``{{``\nand ``}}``. The ``{{ ... }}`` constructs are called **code tags**. There\nare two kinds of code tags: *inline* and *multiline*.\n\nInline Code Tags\n^^^^^^^^^^^^^^^^\n\nInline code tags occur entirely on the same line, i.e. the closing\n``}}`` appears on the same line as the opening ``{{``. Here is an\nexample of an inline code tag:\n\n.. code:: python\n\n    There are {{ 5 + 2 }} days in a week.\n\nThe above, when processed by pypage, yields:\n\n::\n\n    There are 7 days in a week.\n\nThe Python ``eval`` statement is used to execute the code in an inline\ncode tag. The result of the expression evaluation is converted into a\nstring (with ``str``) and the code tag is replaced with it.\n\nMultiline Code Tags\n^^^^^^^^^^^^^^^^^^^\n\nMultiline code tags span multiple lines. The presence of one or more\nnewline (``\\n``) characters between the ``{{`` and ``}}`` distinguishes\nit from an inline code tag. Here's an example:\n\n.. code:: python\n\n    {{\n        x = 5\n        y = 2\n\n        write(\"There are\", x + y, \"days in a week.\")\n    }}\n\nThe Python ``exec`` function is used to execute the code in a multiline\ncode tag.\n\nWhy have distinct inline code tags? It's easier to write ``{{x}}`` than\nto write ``{{ write(x) }}``. Many a time, all we need to do is inject\nthe value of a variable at a specific location in the document.\n\nExecution Environment\n^^^^^^^^^^^^^^^^^^^^^\n\nAll code is executed in a shared common environment. I.e., the ``locals`` and\n``globals`` passed into ``eval`` and ``exec`` is a single shared dictionary,\nfor all code tags in the same file.\n\nAs such, a variable instantiated in a code tag at the\nbeginning of the document, will be available to all other code tags in\nthe document. When pypage is invoked as library, an initial seed\nenvironment consisting of a Python dictionary mapping variable names to\nvalues, can be provided.\n\nThe write function\n''''''''''''''''''\n\nA ``write`` function similar to the Python 3's ``print`` function\nis accessible from both kinds of code tags. It writes text into\nthe document that substitutes/replaces the code tag it's used in.\n\n.. code:: python\n\n    write(*object, sep=' ', end='\\n')\n\nObjects passed to it are stringified with ``str``, concatenated together\nwith ``sep``, and terminated with ``end``. The outputs of multiple calls\nto ``write`` in a code tag are concatenated together, and the resulting\nfinal output is injected in place of the code tag.\n\nIf ``write`` is called from an inline code tag, the result of evaluating\nthe expression (a ``None``, since ``write`` will return a ``None``) is\nignored, and the output of the ``write`` call is used instead.\n\nBlock Tags\n----------\n\nBlock tags simplify certain tasks that would otherwise be cumbersome and\nugly if done exclusively with code tags. One of the things it lets you\ndo is wrap part of your page in an `if/else\nconditional <http://en.wikipedia.org/wiki/Conditional_(computer_programming)>`__,\nor a `for/while\nloop <http://en.wikipedia.org/wiki/Control_flow#Loops>`__.\n\nHere's an example of the ``for`` block tag:\n\n.. code:: python\n\n    {% for i in range(10) %}\n        The square of {{i}} is {{i*i}}.\n    {% %}\n\nA block tag begins with ``{% tag_name ... %}`` and ends with ``{% %}``.\nOptionally, the end ``{% %}`` can be of the form ``{% endtag_name %}``\n(i.e. prepend the ``tag_name`` with ``end``), which in the above example\nwould be ``{% endfor %}``).\n\nConditional Blocks\n^^^^^^^^^^^^^^^^^^\n\nIt's best to explain this with an example:\n\n.. code:: python\n\n    Hey,\n    {{\n      import random\n      # Randomly pick a greeting\n      greeting = random.randint(1,4)\n    }}\n    {% if greeting == 1 %}\n      Hello\n    {% elif greeting == 2 %}\n      Bonjour\n    {% elif greeting == 3 %}\n      Hey\n    {% else %}\n      Hi\n    {% %}\n\nWhen the above template is run, the resulting page will contain a\nrandomly chosen greeting. As is evident, pypage syntax for if/elif/else\nconditions closely mirrors Python's. The terminal ``{% %}`` can be\nreplaced with an ``{% endif %}`` with no change in meaning (as with any\nblock tag).\n\nFor Loops\n^^^^^^^^^\n\nLet's start with a simple example:\n\n.. code:: python\n\n    {% for vowel in ['a', 'e', 'i', 'o', 'u'] %}{{vowel}} {% %}\n\nThis will print out the vowels with a space after every character.\n\nNow that's an ordinary for loop. pypage permits for loops that are more\nexpressive than traditional Python for loops, by leveraging Python's\n*generator expressions*.\n\nHere's an example of something that would be impossible to do in Python\n(with a regular for loop):\n\n.. code:: python\n\n    {% for x in [1,2,3] for y in ['a','b','c'] %}\n        {{x}} ~ {{y}}\n    {%%}\n\nThe above loop would result in:\n\n::\n\n    1 ~ a\n    1 ~ b\n    1 ~ c\n    2 ~ a\n    2 ~ b\n    2 ~ c\n    3 ~ a\n    3 ~ b\n    3 ~ c\n\n*Internally*, pypage morphs the expression\n``for x in [1,2,3] for y in ['a','b','c']`` into the generator\nexpression ``(x, y) for x in [1,2,3] for y in ['a','b','c']``. It\nexposes the the loop variables ``x`` and ``y`` by injecting them into\nyour namespace.\n\n*Note:* Injected loop variables replace variables with the same name for\nthe duration of the loop. After the loop, the old variables with the\nidentical names are restored (pypage backs them up).\n\nWhile Loops\n^^^^^^^^^^^\n\nA while loops looks like ``{{% while condition %}} ... {{% %}``, where\n``condition`` can be any Python expression. Here's an example:\n\n.. code:: python\n\n    {{\n        i = 10\n        j = 20\n    }}\n    Numbers from {{i}} to {{j}}:\n    {% while i <= j %}\n    {{\n        write(str(i))\n        i += 1\n    }}\n    {% %}\n\nThis would simply list the numbers from 10 to 20.\n\ndofirst Loops\n'''''''''''''\n\n.. code:: python\n\n    {% while dofirst False %}\n    That's all, folks!\n    {%%}\n\nAdding a ``dofirst`` right after the ``while`` and before the expression\nensures that the loop is run *at least once*, before the condition is\nevaluated.\n\nLong Loops\n''''''''''\n\nIf a loop runs *for more than 2 seconds*, pypage stops executing it, and\nwrites an error message to ``stdout`` saying that the loop had been\nterminated. As pypage is mostly intended to be used as a templatig\nlanguage, loops generally shouldn't be running for longer than two\nseconds, and this timeout was added to make it easier to catch accidental\ninfinite loops. If you actually need a loop to run for longer than 2\nseoncds, you can add the keyword ``slow`` right after the condition expression\n(``{{% while condition slow %}}``), and that would suppress this 2-second timeout.\n\nCapture Blocks\n^^^^^^^^^^^^^^\n\nYou can capture the output of part of your page using the ``capture``\ntag:\n\n.. code:: python\n\n    {% capture x %}\n      hello {{\"bob\"}}\n    {% %}\n\nThe above tag will not yield any output, but rather a new variable ``x``\nwill be created that captures the output of everything enclosed by it\n(which in this case is ``\"hello bob\"``).\n\nFiner Details\n-------------\n\nInheritance (with inject and exists)\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nThe approach taken by pypage toward template inheritance is quite distinct from that of other\ntemplating engines (`like Jinja's <http://jinja.pocoo.org/docs/2.10/templates/#template-inheritance>`_).\nIt's a lot simpler. You call a pypage-provided function ``inject`` with the path of a *pypage template* you want\nto inject (i.e. \"*extend*\" in Jinja parlance), and pypage will process that template under the current scope (with all\npreviously defined variables being available to the injected template), and the ``inject`` function will return its output.\n\nA base template could look like this:\n\n.. code:: html\n\n    <html>\n    <head>\n        <title>\n            {% if exists('title') %}\n            {{ title }}\n            {% else %}\n            No title\n            {% %}\n        </title>\n    </head>\n    <body>\n    {{ body }}\n    </body>\n    </html>\n\nA derived templates only needs to define ``body`` and optionally ``title``, to \"extend\" the template above.\n\n.. code::\n\n    {% capture body %}\n    The HTML body content would go in here.\n    {% %}\n    {{ inject('...path to the base template...') }}\n\nWe didn't specify a ``title`` above, but if we wanted to, we'd just need to make sure it was defined before ``inject``\nwas called. The base template checks whether a ``title`` variable exists by calling the function ``exists``. As is obvious,\nthe ``exists`` function simply takes a variable name as a string, and returns a boolean indicating whether the variable\nexists in the scope.\n\nThis approach to inheritance is explicit and easy-to-grasp. Rather than have complex inheritance rules, with a default\nblock definition that is optionally overridden by a derived template, we make things more explicit by using conditionals\nfor cases where we want to provide a default/fallback definition. We error out if a definition is expected to be provided,\nand is not present. The output of the \"dervied\" template is clear and obvious, with this approach.\n\nThe include function\n''''''''''''''''''''\n\nIf you want to include (as in, substitute) a file directly without processing it with pypage, you can use the\n``include`` function. It functions like the ``inject`` function, taking the path to a file as argument, and\nreturning the contents of the file unprocessed.\n\nComments\n^^^^^^^^\n\nComment Tags\n''''''''''''\n\nAnything bounded by ``{#`` and ``#}`` will be omitted from the output.\nFor example:\n\n.. code:: html\n\n    <p>\n      Lorem ipsum dolor sit amet\n      {#\n        <ul>\n            Non sequitur\n        </ul>\n      #}\n      consectetur adipisicing elit\n    </p>\n\nComment Blocks\n''''''''''''''\n\nYou can also easily comment an existing block, by simply placing the word ``comment`` in front of it:\n\n.. code:: html\n\n    <p>\n      Lorem ipsum dolor sit amet\n        {% comment for i in range(10) %}\n            N = {{i}}\n        {% %}\n      consectetur adipisicing elit\n    </p>\n\nThe ``comment`` keyword before the ``for`` above results in the entire block\nbeing commented out and omitted from the output.\n\nWhitespace & Indentation\n^^^^^^^^^^^^^^^^^^^^^^^^\n\nWhitespace Removal\n''''''''''''''''''\n\nIf a block tag is on a line by itself, surrounded only by whitespace,\nthen that whitespace is automatically excluded from the output. This\nallows you indent your block tags without worrying about excess\nwhitespace in the generated document.\n\nAutomatic Indentation\n'''''''''''''''''''''\n\npypage smartly handles indentation for you. In a multi-line code tag, if\nyou consistently indent your Python code with a specific amount of\nwhitespace, that indentation will be stripped off before executing the\ncode block (as Python is indentation-sensitive), and the resulting\noutput of that code block will be re-indented with same whitespace that\nthe initial code block was.\n\nThe whitespace preceding the second line of code determines the\nperipheral indentation for the entiee block. All subsequent lines (after\nsecond) must begin with exact same whitespace that preceded the second\nline, or be an empty line.\n\nFor example:\n\n.. code:: html\n\n    <p>\n      Lorem ipsum dolor sit amet\n        <ul>\n          {{\n            def foo():\n              write(\"Hello!\")\n            foo()\n          }}\n        </ul>\n      consectetur adipisicing elit\n    </p>\n\nwould produce the following output:\n\n.. code:: html\n\n    <p>\n      Lorem ipsum dolor sit amet\n        <ul>\n            Hello!\n        </ul>\n      consectetur adipisicing elit\n    </p>\n\nNote that the ``Hello!`` was indented with same whitespace that the code\nin the code block was.\n\npypage automatically intends the output of a multi-line tag to match the\nindentation level of the code tag. The number of whitespace characters\nat the beginning of the second line of the code block determines the\nindentation level for the whole block. All lines of code following the\nsecond line must at least have the same level of indentation as the\nsecond line (or else, a PypageSyntaxError exception will be thrown).\n\nLicense\n^^^^^^^\n\n`Apache License Version\n2.0 <https://www.apache.org/licenses/LICENSE-2.0>`__\n\n.. |build| image:: https://travis-ci.org/arjun-menon/pypage.svg?branch=master\n   :target: https://travis-ci.org/arjun-menon/pypage\n.. |pypi| image:: https://badge.fury.io/py/pypage.svg\n   :target: https://pypi.python.org/pypi/pypage\n.. |docs| image:: https://readthedocs.org/projects/pypage/badge/?version=latest&style=flat\n   :target: https://pypage.readthedocs.io/en/latest/",
        "description_content_type": "",
        "docs_url": null,
        "download_url": "https://github.com/arjun-menon/pypage/archive/v2.0.7.tar.gz",
        "downloads": {
            "last_day": -1,
            "last_month": -1,
            "last_week": -1
        },
        "home_page": "https://github.com/arjun-menon/pypage",
        "keywords": "templating enigne text processing static generator",
        "license": "Apache",
        "maintainer": "",
        "maintainer_email": "",
        "name": "pypage",
        "package_url": "https://pypi.org/project/pypage/",
        "platform": "",
        "project_url": "https://pypi.org/project/pypage/",
        "project_urls": {
            "Download": "https://github.com/arjun-menon/pypage/archive/v2.0.7.tar.gz",
            "Homepage": "https://github.com/arjun-menon/pypage"
        },
        "release_url": "https://pypi.org/project/pypage/2.0.7/",
        "requires_dist": null,
        "requires_python": "",
        "summary": "Light-weight Python Templating Engine",
        "version": "2.0.7"
    },
    "last_serial": 4190260,
    "releases": {
        "2.0.3": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "ff2c31b885dff3bc90076d5de23080a0",
                    "sha256": "84710d71756762f8a71735bf54acd3185dd0750f195969f6264cade3b7751fd5"
                },
                "downloads": -1,
                "filename": "pypage-2.0.3.tar.gz",
                "has_sig": false,
                "md5_digest": "ff2c31b885dff3bc90076d5de23080a0",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 13747,
                "upload_time": "2016-11-03T23:11:43",
                "url": "https://files.pythonhosted.org/packages/dc/51/5f0ca3264ef42c58bcb521f96eb660a04f290659616d54cac45188a751f5/pypage-2.0.3.tar.gz"
            }
        ],
        "2.0.4": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "37460857684ba4a0bac1e1bcb5ec585f",
                    "sha256": "232acaf40842283bec702742f6f53519ae0ba7a164d3afea7a83df1d5ef165ab"
                },
                "downloads": -1,
                "filename": "pypage-2.0.4.tar.gz",
                "has_sig": false,
                "md5_digest": "37460857684ba4a0bac1e1bcb5ec585f",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 13889,
                "upload_time": "2016-11-10T18:12:01",
                "url": "https://files.pythonhosted.org/packages/af/5d/e7a33ca2631db565407d8ca52d192e8a4fde1ade74541b2934acf9fb314d/pypage-2.0.4.tar.gz"
            }
        ],
        "2.0.5": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "b9a58e345fbe24b0bcdc7662cd794772",
                    "sha256": "dbccd0f1391b66f6e86a13ac6b6ee474a25c146561945a98a5bcb6a64dc74735"
                },
                "downloads": -1,
                "filename": "pypage-2.0.5.tar.gz",
                "has_sig": false,
                "md5_digest": "b9a58e345fbe24b0bcdc7662cd794772",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 13884,
                "upload_time": "2016-11-10T18:39:55",
                "url": "https://files.pythonhosted.org/packages/32/bc/c523d6167ce3f36194fbcf268b4d9f8268932be1a4888b3cd7eec35d20bf/pypage-2.0.5.tar.gz"
            }
        ],
        "2.0.6": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "22158fbc892f113144b1bb369f6c7502",
                    "sha256": "ccd1050dfc55e167f0d4f044dcb24c059b60655b9d18479a2b6845fc988c9e07"
                },
                "downloads": -1,
                "filename": "pypage-2.0.6.tar.gz",
                "has_sig": false,
                "md5_digest": "22158fbc892f113144b1bb369f6c7502",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 19867,
                "upload_time": "2018-08-13T15:11:17",
                "url": "https://files.pythonhosted.org/packages/0b/63/fd900c0ad77415cb4dbf31fe3a98c0d208ff81081942f2c5edacb2a0213f/pypage-2.0.6.tar.gz"
            }
        ],
        "2.0.7": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "e0044953df460a5ad4259f61b93e6f58",
                    "sha256": "10ae4ff1a93cb2f9882f3935a6e956752f83e52580528f3cbe818c3710cc362f"
                },
                "downloads": -1,
                "filename": "pypage-2.0.7.tar.gz",
                "has_sig": false,
                "md5_digest": "e0044953df460a5ad4259f61b93e6f58",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 20214,
                "upload_time": "2018-08-20T22:40:39",
                "url": "https://files.pythonhosted.org/packages/0a/d6/964e1e09ef14c4ec8060eeaaab7c5eee970600080e8f56f0d194c10ecf8c/pypage-2.0.7.tar.gz"
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "e0044953df460a5ad4259f61b93e6f58",
                "sha256": "10ae4ff1a93cb2f9882f3935a6e956752f83e52580528f3cbe818c3710cc362f"
            },
            "downloads": -1,
            "filename": "pypage-2.0.7.tar.gz",
            "has_sig": false,
            "md5_digest": "e0044953df460a5ad4259f61b93e6f58",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": null,
            "size": 20214,
            "upload_time": "2018-08-20T22:40:39",
            "url": "https://files.pythonhosted.org/packages/0a/d6/964e1e09ef14c4ec8060eeaaab7c5eee970600080e8f56f0d194c10ecf8c/pypage-2.0.7.tar.gz"
        }
    ]
}