[ { "path": ".gitignore", "content": "*.pyc\n# don't include third-party dependencies.\n!lib/README.md\n.DS_Store\n" }, { "path": ".playground", "content": "{\n \"template_name\" : \"Flask web framework\",\n \"template_description\" : \"Skeleton app based on Flask microframework (http://flask.pocoo.org/)\",\n \"open_files\": [\"main.py\"]\n}\n" }, { "path": "CONTRIB.md", "content": "# How to become a contributor and submit your own code\n\n## Contributor License Agreements\n\nWe'd love to accept your sample apps and patches! Before we can take them, we have to jump a couple of legal hurdles.\n\nPlease fill out either the individual or corporate Contributor License Agreement (CLA).\n\n * If you are an individual writing original source code and you're sure you own the intellectual property, then you'll need to sign an [individual CLA](http://code.google.com/legal/individual-cla-v1.0.html).\n * If you work for a company that wants to allow you to contribute your work, then you'll need to sign a [corporate CLA](http://code.google.com/legal/corporate-cla-v1.0.html).\n\nFollow either of the two links above to access the appropriate CLA and instructions for how to sign and return it. Once we receive it, we'll be able to accept your pull requests.\n\n## Contributing A Patch\n\n1. Submit an issue describing your proposed change to the repo in question.\n1. The repo owner will respond to your issue promptly.\n1. If your proposed change is accepted, and you haven't already done so, sign a Contributor License Agreement (see details above).\n1. Fork the desired repo, develop and test your code changes.\n1. Ensure that your code adheres to the existing style in the sample to which you are contributing. Refer to the [Google Cloud Platform Samples Style Guide](https://github.com/GoogleCloudPlatform/Template/wiki/style.html) for the recommended coding standards for this organization.\n1. Ensure that your code has an appropriate set of unit tests which all pass.\n1. Submit a pull request.\n\n## Contributing A New Sample App\n\n1. Submit an issue to the GoogleCloudPlatform/Template repo describing your proposed sample app.\n1. The Template repo owner will respond to your enhancement issue promptly. Instructional value is the top priority when evaluating new app proposals for this collection of repos.\n1. If your proposal is accepted, and you haven't already done so, sign a Contributor License Agreement (see details above).\n1. Create your own repo for your app following this naming convention:\n * {product}-{app-name}-{language}\n * products: appengine, compute, storage, bigquery, prediction, cloudsql\n * example: appengine-guestbook-python\n * For multi-product apps, concatenate the primary products, like this: compute-appengine-demo-suite-python.\n * For multi-language apps, concatenate the primary languages like this: appengine-sockets-python-java-go.\n1. Clone the README.md, CONTRIB.md and LICENSE files from the GoogleCloudPlatform/Template repo.\n1. Ensure that your code adheres to the existing style in the sample to which you are contributing. Refer to the [Google Cloud Platform Samples Style Guide](https://github.com/GoogleCloudPlatform/Template/wiki/style.html) for the recommended coding standards for this organization.\n1. Ensure that your code has an appropriate set of unit tests which all pass.\n1. Submit a request to fork your repo in GoogleCloudPlatform organizationt via your proposal issue.\n" }, { "path": "LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "README.md", "content": "![status: inactive](https://img.shields.io/badge/status-inactive-red.svg)\n\nThis project is no longer actively developed or maintained.\n\nFor new work on this check out [flask Hello World](https://github.com/GoogleCloudPlatform/python-docs-samples/tree/master/appengine/standard/flask/hello_world).\n\n\n## Python Flask Skeleton for Google App Engine\n\nA skeleton for building Python applications on Google App Engine with the\n[Flask micro framework](http://flask.pocoo.org).\n\nSee our other [Google Cloud Platform github\nrepos](https://github.com/GoogleCloudPlatform) for sample applications and\nscaffolding for other python frameworks and use cases.\n\n## Run Locally\n1. Install the [App Engine Python SDK](https://developers.google.com/appengine/downloads).\nSee the README file for directions. You'll need python 2.7 and [pip 1.4 or later](http://www.pip-installer.org/en/latest/installing.html) installed too.\n\n2. Clone this repo with\n\n ```\n git clone https://github.com/GoogleCloudPlatform/appengine-flask-skeleton.git\n ```\n3. Install dependencies in the project's lib directory.\n Note: App Engine can only import libraries from inside your project directory.\n\n ```\n cd appengine-flask-skeleton\n pip install -r requirements.txt -t lib\n ```\n4. Run this project locally from the command line:\n\n ```\n dev_appserver.py .\n ```\n\nVisit the application [http://localhost:8080](http://localhost:8080)\n\nSee [the development server documentation](https://developers.google.com/appengine/docs/python/tools/devserver)\nfor options when running dev_appserver.\n\n## Deploy\nTo deploy the application:\n\n1. Use the [Admin Console](https://appengine.google.com) to create a\n project/app id. (App id and project id are identical)\n1. [Deploy the\n application](https://developers.google.com/appengine/docs/python/tools/uploadinganapp) with\n\n ```\n appcfg.py update -A -V v1 .\n ```\n \n If this isn't your first deployment, you will need to set the new version as the default version with\n \n ```\n appcfg.py set_default_version -V v1 -A \n ```\n\n1. Congratulations! Your application is now live at your-app-id.appspot.com\n\n## Next Steps\nThis skeleton includes `TODO` markers to help you find basic areas you will want\nto customize.\n\n### Relational Databases and Datastore\nTo add persistence to your models, use\n[NDB](https://developers.google.com/appengine/docs/python/ndb/) for\nscale. Consider\n[CloudSQL](https://developers.google.com/appengine/docs/python/cloud-sql)\nif you need a relational database.\n\n### Installing Libraries\nSee the [Third party\nlibraries](https://developers.google.com/appengine/docs/python/tools/libraries27)\npage for libraries that are already included in the SDK. To include SDK\nlibraries, add them in your app.yaml file. Other than libraries included in\nthe SDK, only pure python libraries may be added to an App Engine project.\n\n### Feedback\nStar this repo if you found it useful. Use the github issue tracker to give\nfeedback on this repo.\n\n## Contributing changes\nSee [CONTRIB.md](CONTRIB.md)\n\n## Licensing\nSee [LICENSE](LICENSE)\n\n## Author\nLogan Henriquez and Johan Euphrosine\n" }, { "path": "app.yaml", "content": "# This file specifies your Python application's runtime configuration\n# including URL routing, versions, static file uploads, etc. See\n# https://developers.google.com/appengine/docs/python/config/appconfig\n# for details.\n\nruntime: python27\napi_version: 1\nthreadsafe: yes\n\n# Handlers define how to route requests to your application.\nhandlers:\n\n# App Engine serves and caches static files contained in the listed directories\n# (and subdirectories). Uncomment and set the directory as needed.\n#- url: /client\n# static_dir: client\n\n# This handler tells app engine how to route requests to a WSGI application.\n# The script value is in the format .\n# where is a WSGI application object.\n- url: .* # This regex directs all routes to main.app\n script: main.app\n\n# Third party libraries that are included in the App Engine SDK must be listed\n# here if you want to use them. See\n# https://developers.google.com/appengine/docs/python/tools/libraries27 for\n# a list of libraries included in the SDK. Third party libs that are *not* part\n# of the App Engine SDK don't need to be listed here, instead add them to your\n# project directory, either as a git submodule or as a plain subdirectory.\n# TODO: List any other App Engine SDK libs you may need here.\n#libraries:\n#- name: jinja2\n# version: latest\n" }, { "path": "appengine_config.py", "content": "\"\"\"\n`appengine_config.py` is automatically loaded when Google App Engine\nstarts a new instance of your application. This runs before any\nWSGI applications specified in app.yaml are loaded.\n\"\"\"\n\nfrom google.appengine.ext import vendor\n\n# Third-party libraries are stored in \"lib\", vendoring will make\n# sure that they are importable by the application.\nvendor.add('lib')\n" }, { "path": "lib/Flask-0.10.dist-info/DESCRIPTION.rst", "content": "Flask\n-----\n\nFlask is a microframework for Python based on Werkzeug, Jinja 2 and good\nintentions. And before you ask: It's BSD licensed!\n\nFlask is Fun\n````````````\n\n.. code:: python\n\n from flask import Flask\n app = Flask(__name__)\n\n @app.route(\"/\")\n def hello():\n return \"Hello World!\"\n\n if __name__ == \"__main__\":\n app.run()\n\nAnd Easy to Setup\n`````````````````\n\n.. code:: bash\n\n $ pip install Flask\n $ python hello.py\n * Running on http://localhost:5000/\n\nLinks\n`````\n\n* `website `_\n* `documentation `_\n* `development version\n `_\n\n\n\n" }, { "path": "lib/Flask-0.10.dist-info/METADATA", "content": "Metadata-Version: 2.0\nName: Flask\nVersion: 0.10\nSummary: A microframework based on Werkzeug, Jinja2 and good intentions\nHome-page: http://github.com/mitsuhiko/flask/\nAuthor: Armin Ronacher\nAuthor-email: armin.ronacher@active-4.com\nLicense: BSD\nPlatform: any\nClassifier: Development Status :: 4 - Beta\nClassifier: Environment :: Web Environment\nClassifier: Intended Audience :: Developers\nClassifier: License :: OSI Approved :: BSD License\nClassifier: Operating System :: OS Independent\nClassifier: Programming Language :: Python\nClassifier: Programming Language :: Python :: 2.6\nClassifier: Programming Language :: Python :: 2.7\nClassifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content\nClassifier: Topic :: Software Development :: Libraries :: Python Modules\nRequires-Dist: Werkzeug (>=0.7)\nRequires-Dist: Jinja2 (>=2.4)\nRequires-Dist: itsdangerous (>=0.21)\n\nFlask\n-----\n\nFlask is a microframework for Python based on Werkzeug, Jinja 2 and good\nintentions. And before you ask: It's BSD licensed!\n\nFlask is Fun\n````````````\n\n.. code:: python\n\n from flask import Flask\n app = Flask(__name__)\n\n @app.route(\"/\")\n def hello():\n return \"Hello World!\"\n\n if __name__ == \"__main__\":\n app.run()\n\nAnd Easy to Setup\n`````````````````\n\n.. code:: bash\n\n $ pip install Flask\n $ python hello.py\n * Running on http://localhost:5000/\n\nLinks\n`````\n\n* `website `_\n* `documentation `_\n* `development version\n `_\n\n\n\n" }, { "path": "lib/Flask-0.10.dist-info/RECORD", "content": "flask/__init__.py,sha256=Hmok7MXSW0QTF-6TCFPfRqpHlVq1zOihqSMnHfXysvo,1672\r\nflask/_compat.py,sha256=ug9fCmzhMFE1ecCpZLvbHSTXluYCcLXt3_8SNwGNZyg,2164\r\nflask/app.py,sha256=U7K6oLEhv59ZrIJEzfVfVcB33PYKRQQN2CYLalOaNSA,76786\r\nflask/blueprints.py,sha256=OBo5Mkl_y54l0xPuLptXz54CDvvRX5tApMKIXyvykTk,16320\r\nflask/config.py,sha256=NhTkQX2yFgPDZD-t3phxcS2kw6i2kA7RHgX0fDoHXbQ,6234\r\nflask/ctx.py,sha256=Ka_Ql-ZgRU7z9aVkET0_WwwTKguaUozg3ezDcm-tUKY,14266\r\nflask/debughelpers.py,sha256=iyJC--eX8ANvci4MsFbtwc_PkwVlbCrZGHCOnQsOHFs,3508\r\nflask/exthook.py,sha256=dfW3DBBI8LyPrwacwZN8q0u0Q8gBBCXtocJ7wBnvgAs,5087\r\nflask/globals.py,sha256=kNGf5b05C8AjTzZJhBUbbtgufgumOnAPk9g_LYh0Rv0,1137\r\nflask/helpers.py,sha256=roTv_nwOjhAhUWvW-Uz_Ex9SLA32mEx_7vfZagZjizA,33793\r\nflask/json.py,sha256=qPIc18Pd2jj3EDJMan1BmkYxhJKYKpBw4oPp8Z6b2uo,7530\r\nflask/logging.py,sha256=EkiNIJbQyeUb8nipAURO8CQJwC4BESjkM_snQIRCeIc,1398\r\nflask/module.py,sha256=2J_pmW7jaFye1FtNTn5jfX-HxBqMc9EZzSLUXxiV-7c,1363\r\nflask/sessions.py,sha256=X0yDRq4cpKluFlDupBDFAouQxJWP09sSES8pKnXpcPg,12882\r\nflask/signals.py,sha256=DmcQfKzlPdLoY00fxf2BsH3SsDFiFSppCbX9Yfdv_ng,2140\r\nflask/templating.py,sha256=joMsvkTasZUJxdipA0BnrbfIMidzzBzPug-dIaW0Tzo,4707\r\nflask/testing.py,sha256=C8b-44Ro9hsFH5-eBksgjBWLrPznESmX9rdMFBkIbp4,5003\r\nflask/views.py,sha256=S2fRXcRsyy6FUKJ9tZh39LLH22vOeZvYMLZQKT1pc6Y,5642\r\nflask/wrappers.py,sha256=67pssdNN3I4dKSVUVru5HNUteAeF2V6_7qpLZoVwmiI,6709\r\nflask/ext/__init__.py,sha256=M97BrvCtJFgcWpt8Jo1qg2nLkQaGd-4whLkdHfi-rE8,842\r\nflask/testsuite/__init__.py,sha256=zCtem4AVtj6_GSTxCFUHElbH3g6LYY9ApIr7NVUWmGU,7022\r\nflask/testsuite/appctx.py,sha256=vt0c0gfqcUYXfJ7t2IRd3Gg0BzSaLKO2bx9d5Id7m6M,3116\r\nflask/testsuite/basic.py,sha256=EX66aNjBKOt5I8PWcpstzTCsy2O1M29kSDxAwLeySPg,42765\r\nflask/testsuite/blueprints.py,sha256=uLsqDu1AyTPeQJ6Ab1RHKPcYbo5s-7adSW5XSE1Fa0o,28089\r\nflask/testsuite/config.py,sha256=h64-JdPdlU6a7O8YfwAEriYZ30yAD1c_vjjYgyJ-JzA,11820\r\nflask/testsuite/deprecations.py,sha256=tsvmOrjcG1tV6vV4ySL5a7V4o77Tnf4wd_-yqVhUXIc,511\r\nflask/testsuite/examples.py,sha256=KyCnXuKNFfBEAyPl12a-etPF_PRufrJGwP09zTvl714,942\r\nflask/testsuite/ext.py,sha256=5jOofZijgqi5OmRV7YxB7RS-RY7HuSj3L90316yH_IY,5156\r\nflask/testsuite/helpers.py,sha256=nSZ1xuJeOJWcK6_wSv_L3tl8OAe_zcaRT_IoPpZPcvg,21657\r\nflask/testsuite/regression.py,sha256=QDMe2hkgu3lV8RaUhHsICciKWhSC6L2TaYe9qITlyL8,3198\r\nflask/testsuite/reqctx.py,sha256=EriP7GP23zt3zWKabTvEzldvp0EqRe--v8W-ZKwCz9k,5960\r\nflask/testsuite/signals.py,sha256=jclEzgHqRhPgM3uoxRbgmXIiFm_HWlrkqT5M0hBv5xw,4807\r\nflask/testsuite/subclassing.py,sha256=TT-nltJBy1Xi1BxcdztGZ3hmMq9h_nk1CVeSy9qBrXQ,1214\r\nflask/testsuite/templating.py,sha256=2lg2-MPMGkmlKap9M711uVXC08iZU8w3EtmTI2la_N8,11237\r\nflask/testsuite/testing.py,sha256=ihNMpcAxZ3wArSjUvFuCaHSREgjQNV5UAS2W1vYSNt4,7411\r\nflask/testsuite/views.py,sha256=2ThDMtk1zoMvuXzRuP1Wh3e_hgDwPtyu76TXycVyhqc,5068\r\nflask/testsuite/static/index.html,sha256=f28C_muYEAWoHyfaubxti-TLB0wMjFZHII3e9TRsmsI,22\r\nflask/testsuite/templates/_macro.html,sha256=XA2qnwpJpO3auSjZlKXODzeU4Fcnim12ie5lMXeL8ms,55\r\nflask/testsuite/templates/context_template.html,sha256=hXvHzdggsqqO2eXRlb6EhGDTTzPIQicaMk2EibzagDQ,36\r\nflask/testsuite/templates/escaping_template.html,sha256=ORPM3QIOIu_lWv9M101bPHZt-bmy8Biu2663aAoO50g,147\r\nflask/testsuite/templates/mail.txt,sha256=8f9j1PxUo_deGbrpJuDdrii16qE-xtV9RU6mYPVE_64,14\r\nflask/testsuite/templates/simple_template.html,sha256=d0akkxWQ1UQkDiL45b8nUvCE0KpL579DhioYlv713bE,23\r\nflask/testsuite/templates/template_filter.html,sha256=ZIk3H4Oa8fDn62Ij6jDzdHukLj3RXGtmBnkEtgTUmQ0,25\r\nflask/testsuite/templates/template_test.html,sha256=g3ZgUQN0PaOiz289_AxNeP3ICfR29ogzbQl3fCvxK_8,51\r\nflask/testsuite/templates/nested/nested.txt,sha256=76PlNDtwDVWjZMPHRlBqSX95jY52e_RWZCJKZfRWkAU,11\r\nflask/testsuite/test_apps/config_module_app.py,sha256=BaBJCCI4TcOc9Kc5OvlgmaCtfQH8D31xVZMLZ3FmyRE,101\r\nflask/testsuite/test_apps/flask_newext_simple.py,sha256=IIsV29nQ37pV2Z3O8GQ5a33YkIlII8B0rbOqz5k4ZxQ,25\r\nflask/testsuite/test_apps/importerror.py,sha256=gA8IjK673B4Rit7pYYnkspF2k9_zpztPmiMYgrwgzdk,46\r\nflask/testsuite/test_apps/main_app.py,sha256=mah5bd5ObZV6bl4YbnJEEdQcr5NqgMFmZqcaAITIReE,90\r\nflask/testsuite/test_apps/blueprintapp/__init__.py,sha256=OeOuAvS6IghuIekcXqfgPuoACL6JSxKw_xOpvgTx7lE,200\r\nflask/testsuite/test_apps/blueprintapp/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\r\nflask/testsuite/test_apps/blueprintapp/apps/admin/__init__.py,sha256=L5kSKkfOewREXLveDLogxtGyF2UrkIczxo4PZrjYCl8,362\r\nflask/testsuite/test_apps/blueprintapp/apps/admin/static/test.txt,sha256=lcPiuni6LR_rw5mxyjRmz8iMcifiSSNqPFlIrmLKzjY,11\r\nflask/testsuite/test_apps/blueprintapp/apps/admin/static/css/test.css,sha256=F1DG-ABW3o6yAD9Nc6IzV9iYefZeOHhn59009LMJboY,18\r\nflask/testsuite/test_apps/blueprintapp/apps/admin/templates/admin/index.html,sha256=2OWS6QYqxaarnZAWkLvam0P2QSodRNkA6M05eEOVLw4,21\r\nflask/testsuite/test_apps/blueprintapp/apps/frontend/__init__.py,sha256=djItvU0fqQg-MOlVoJR3--6cYf4VT1SI0WFsQyjQk4o,204\r\nflask/testsuite/test_apps/blueprintapp/apps/frontend/templates/frontend/index.html,sha256=hcC7DORSYxGNK5DAICVx1BeFVlzaanxcIhODQwm9rwg,24\r\nflask/testsuite/test_apps/config_package_app/__init__.py,sha256=BaBJCCI4TcOc9Kc5OvlgmaCtfQH8D31xVZMLZ3FmyRE,101\r\nflask/testsuite/test_apps/flask_broken/__init__.py,sha256=CDC0TTkjrjeLs7ZXzLwdjS0yFiE2DM9uZ65q927Xx-c,48\r\nflask/testsuite/test_apps/flask_broken/b.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\r\nflask/testsuite/test_apps/flask_newext_package/__init__.py,sha256=UX_8L5rL7scxeUhXbUklOXDzE16eQ0eSdykHJvCe9O4,26\r\nflask/testsuite/test_apps/flask_newext_package/submodule.py,sha256=VBKM2Msdeq6F7ziaPiwTbcu9c4wAH4kKZH6FDUPi6zg,35\r\nflask/testsuite/test_apps/flaskext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\r\nflask/testsuite/test_apps/flaskext/oldext_simple.py,sha256=fuHRIiStUQIS-JoiE_Vwkc_nRX3qkMETN1yBtEDQyck,25\r\nflask/testsuite/test_apps/flaskext/oldext_package/__init__.py,sha256=u6W0k3--q15e2nTlDWvTA0gvu1EuvaJQGIb-y9gPe8A,26\r\nflask/testsuite/test_apps/flaskext/oldext_package/submodule.py,sha256=VBKM2Msdeq6F7ziaPiwTbcu9c4wAH4kKZH6FDUPi6zg,35\r\nflask/testsuite/test_apps/lib/python2.5/site-packages/site_app.py,sha256=yObUTJgzGrSHwp-eLsE-bMbGmKLogUdE6bCn7jQPR6A,42\r\nflask/testsuite/test_apps/lib/python2.5/site-packages/SiteEgg.egg,sha256=fVBqIK3Yab7f_mM6B5dZO2zN1N9abqQKS1xRIbKNsgc,1218\r\nflask/testsuite/test_apps/lib/python2.5/site-packages/site_package/__init__.py,sha256=yObUTJgzGrSHwp-eLsE-bMbGmKLogUdE6bCn7jQPR6A,42\r\nflask/testsuite/test_apps/moduleapp/__init__.py,sha256=x5mMfvASdMFFNFp0tq2Fwpp_-9DxNlRwHIFxj_bhbnQ,188\r\nflask/testsuite/test_apps/moduleapp/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\r\nflask/testsuite/test_apps/moduleapp/apps/admin/__init__.py,sha256=ESnyU_sz54kX22RJUOyciuHlGz0_c9d1qGxrzke9V7E,259\r\nflask/testsuite/test_apps/moduleapp/apps/admin/static/test.txt,sha256=lcPiuni6LR_rw5mxyjRmz8iMcifiSSNqPFlIrmLKzjY,11\r\nflask/testsuite/test_apps/moduleapp/apps/admin/static/css/test.css,sha256=F1DG-ABW3o6yAD9Nc6IzV9iYefZeOHhn59009LMJboY,18\r\nflask/testsuite/test_apps/moduleapp/apps/admin/templates/index.html,sha256=2OWS6QYqxaarnZAWkLvam0P2QSodRNkA6M05eEOVLw4,21\r\nflask/testsuite/test_apps/moduleapp/apps/frontend/__init__.py,sha256=qtVGS_XzTw3uxAyEcOi49uXB4o-u4ZEZLQrhwIUkEME,158\r\nflask/testsuite/test_apps/moduleapp/apps/frontend/templates/index.html,sha256=hcC7DORSYxGNK5DAICVx1BeFVlzaanxcIhODQwm9rwg,24\r\nflask/testsuite/test_apps/path/installed_package/__init__.py,sha256=yObUTJgzGrSHwp-eLsE-bMbGmKLogUdE6bCn7jQPR6A,42\r\nflask/testsuite/test_apps/subdomaintestmodule/__init__.py,sha256=o7W5jKRXGVqfjwYKWjI3QX8WUztGxuVnGiZ-wSGd1Fk,74\r\nflask/testsuite/test_apps/subdomaintestmodule/static/hello.txt,sha256=5PvE5WQoKT9dXkOTZ63vfG9F0iAysyTmSTX0dA4uiQI,16\r\nFlask-0.10.dist-info/DESCRIPTION.rst,sha256=YsWE_jM8p5TWeiY2cuesAHH5JUW95FFaHKvruzGCg5o,694\r\nFlask-0.10.dist-info/METADATA,sha256=pqbqQzdvCFKHyFRIFyxq9hyctjcYvH9MGStkHlbfBqk,1557\r\nFlask-0.10.dist-info/metadata.json,sha256=nWJBE8_HRpsHM1zLFJsfFrxuzec2njoS7UDgZMpCiFE,1011\r\nFlask-0.10.dist-info/RECORD,,\r\nFlask-0.10.dist-info/top_level.txt,sha256=dvi65F6AeGWVU0TBpYiC04yM60-FX1gJFkK31IKQr5c,6\r\nFlask-0.10.dist-info/WHEEL,sha256=54bVun1KfEBTJ68SHUmbxNPj80VxlQ0sHi4gZdGZXEY,92\r\nflask/config.pyc,,\r\nflask/testsuite/deprecations.pyc,,\r\nflask/testsuite/test_apps/flaskext/oldext_package/__init__.pyc,,\r\nflask/testsuite/test_apps/blueprintapp/__init__.pyc,,\r\nflask/testsuite/regression.pyc,,\r\nflask/module.pyc,,\r\nflask/debughelpers.pyc,,\r\nflask/testsuite/signals.pyc,,\r\nflask/testsuite/examples.pyc,,\r\nflask/testsuite/test_apps/blueprintapp/apps/frontend/__init__.pyc,,\r\nflask/testsuite/test_apps/moduleapp/apps/__init__.pyc,,\r\nflask/sessions.pyc,,\r\nflask/logging.pyc,,\r\nflask/testsuite/test_apps/path/installed_package/__init__.pyc,,\r\nflask/testsuite/test_apps/flask_broken/__init__.pyc,,\r\nflask/__init__.pyc,,\r\nflask/testsuite/config.pyc,,\r\nflask/testsuite/test_apps/importerror.pyc,,\r\nflask/testsuite/test_apps/flaskext/oldext_simple.pyc,,\r\nflask/testsuite/subclassing.pyc,,\r\nflask/testsuite/__init__.pyc,,\r\nflask/testsuite/test_apps/lib/python2.5/site-packages/site_package/__init__.pyc,,\r\nflask/globals.pyc,,\r\nflask/testsuite/test_apps/lib/python2.5/site-packages/site_app.pyc,,\r\nflask/testsuite/test_apps/subdomaintestmodule/__init__.pyc,,\r\nflask/views.pyc,,\r\nflask/json.pyc,,\r\nflask/testsuite/test_apps/flask_newext_simple.pyc,,\r\nflask/testsuite/test_apps/flask_broken/b.pyc,,\r\nflask/testsuite/test_apps/flask_newext_package/__init__.pyc,,\r\nflask/testsuite/test_apps/config_module_app.pyc,,\r\nflask/testsuite/blueprints.pyc,,\r\nflask/testsuite/test_apps/flaskext/oldext_package/submodule.pyc,,\r\nflask/blueprints.pyc,,\r\nflask/testsuite/test_apps/flaskext/__init__.pyc,,\r\nflask/exthook.pyc,,\r\nflask/testsuite/test_apps/blueprintapp/apps/__init__.pyc,,\r\nflask/testsuite/templating.pyc,,\r\nflask/testsuite/test_apps/main_app.pyc,,\r\nflask/testsuite/testing.pyc,,\r\nflask/_compat.pyc,,\r\nflask/ctx.pyc,,\r\nflask/testsuite/test_apps/moduleapp/apps/admin/__init__.pyc,,\r\nflask/testsuite/test_apps/moduleapp/__init__.pyc,,\r\nflask/testsuite/appctx.pyc,,\r\nflask/app.pyc,,\r\nflask/ext/__init__.pyc,,\r\nflask/testing.pyc,,\r\nflask/wrappers.pyc,,\r\nflask/testsuite/helpers.pyc,,\r\nflask/helpers.pyc,,\r\nflask/testsuite/test_apps/moduleapp/apps/frontend/__init__.pyc,,\r\nflask/testsuite/views.pyc,,\r\nflask/signals.pyc,,\r\nflask/testsuite/test_apps/flask_newext_package/submodule.pyc,,\r\nflask/testsuite/basic.pyc,,\r\nflask/templating.pyc,,\r\nflask/testsuite/test_apps/blueprintapp/apps/admin/__init__.pyc,,\r\nflask/testsuite/reqctx.pyc,,\r\nflask/testsuite/ext.pyc,,\r\nflask/testsuite/test_apps/config_package_app/__init__.pyc,,\r\n" }, { "path": "lib/Flask-0.10.dist-info/WHEEL", "content": "Wheel-Version: 1.0\nGenerator: bdist_wheel (0.24.0)\nRoot-Is-Purelib: true\nTag: py2-none-any\n\n" }, { "path": "lib/Flask-0.10.dist-info/metadata.json", "content": "{\"license\": \"BSD\", \"name\": \"Flask\", \"metadata_version\": \"2.0\", \"generator\": \"bdist_wheel (0.24.0)\", \"summary\": \"A microframework based on Werkzeug, Jinja2 and good intentions\", \"platform\": \"any\", \"run_requires\": [{\"requires\": [\"Werkzeug (>=0.7)\", \"Jinja2 (>=2.4)\", \"itsdangerous (>=0.21)\"]}], \"version\": \"0.10\", \"extensions\": {\"python.details\": {\"project_urls\": {\"Home\": \"http://github.com/mitsuhiko/flask/\"}, \"document_names\": {\"description\": \"DESCRIPTION.rst\"}, \"contacts\": [{\"role\": \"author\", \"email\": \"armin.ronacher@active-4.com\", \"name\": \"Armin Ronacher\"}]}}, \"classifiers\": [\"Development Status :: 4 - Beta\", \"Environment :: Web Environment\", \"Intended Audience :: Developers\", \"License :: OSI Approved :: BSD License\", \"Operating System :: OS Independent\", \"Programming Language :: Python\", \"Programming Language :: Python :: 2.6\", \"Programming Language :: Python :: 2.7\", \"Topic :: Internet :: WWW/HTTP :: Dynamic Content\", \"Topic :: Software Development :: Libraries :: Python Modules\"], \"extras\": []}" }, { "path": "lib/Flask-0.10.dist-info/top_level.txt", "content": "flask\n" }, { "path": "lib/Jinja2-2.8.dist-info/DESCRIPTION.rst", "content": "Jinja2\n~~~~~~\n\nJinja2 is a template engine written in pure Python. It provides a\n`Django`_ inspired non-XML syntax but supports inline expressions and\nan optional `sandboxed`_ environment.\n\nNutshell\n--------\n\nHere a small example of a Jinja template::\n\n {% extends 'base.html' %}\n {% block title %}Memberlist{% endblock %}\n {% block content %}\n \n {% endblock %}\n\nPhilosophy\n----------\n\nApplication logic is for the controller but don't try to make the life\nfor the template designer too hard by giving him too few functionality.\n\nFor more informations visit the new `Jinja2 webpage`_ and `documentation`_.\n\n.. _sandboxed: http://en.wikipedia.org/wiki/Sandbox_(computer_security)\n.. _Django: http://www.djangoproject.com/\n.. _Jinja2 webpage: http://jinja.pocoo.org/\n.. _documentation: http://jinja.pocoo.org/2/documentation/\n\n\n" }, { "path": "lib/Jinja2-2.8.dist-info/METADATA", "content": "Metadata-Version: 2.0\nName: Jinja2\nVersion: 2.8\nSummary: A small but fast and easy to use stand-alone template engine written in pure python.\nHome-page: http://jinja.pocoo.org/\nAuthor: Armin Ronacher\nAuthor-email: armin.ronacher@active-4.com\nLicense: BSD\nPlatform: UNKNOWN\nClassifier: Development Status :: 5 - Production/Stable\nClassifier: Environment :: Web Environment\nClassifier: Intended Audience :: Developers\nClassifier: License :: OSI Approved :: BSD License\nClassifier: Operating System :: OS Independent\nClassifier: Programming Language :: Python\nClassifier: Programming Language :: Python :: 2\nClassifier: Programming Language :: Python :: 2.6\nClassifier: Programming Language :: Python :: 2.7\nClassifier: Programming Language :: Python :: 3\nClassifier: Programming Language :: Python :: 3.3\nClassifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content\nClassifier: Topic :: Software Development :: Libraries :: Python Modules\nClassifier: Topic :: Text Processing :: Markup :: HTML\nRequires-Dist: MarkupSafe\nProvides-Extra: i18n\nRequires-Dist: Babel (>=0.8); extra == 'i18n'\n\nJinja2\n~~~~~~\n\nJinja2 is a template engine written in pure Python. It provides a\n`Django`_ inspired non-XML syntax but supports inline expressions and\nan optional `sandboxed`_ environment.\n\nNutshell\n--------\n\nHere a small example of a Jinja template::\n\n {% extends 'base.html' %}\n {% block title %}Memberlist{% endblock %}\n {% block content %}\n \n {% endblock %}\n\nPhilosophy\n----------\n\nApplication logic is for the controller but don't try to make the life\nfor the template designer too hard by giving him too few functionality.\n\nFor more informations visit the new `Jinja2 webpage`_ and `documentation`_.\n\n.. _sandboxed: http://en.wikipedia.org/wiki/Sandbox_(computer_security)\n.. _Django: http://www.djangoproject.com/\n.. _Jinja2 webpage: http://jinja.pocoo.org/\n.. _documentation: http://jinja.pocoo.org/2/documentation/\n\n\n" }, { "path": "lib/Jinja2-2.8.dist-info/RECORD", "content": "jinja2/__init__.py,sha256=c59bnaAFo63I7lYUZlO2UKHj8LPG3JACKnCrwWgvjGY,2326\r\njinja2/_compat.py,sha256=O4FnYOMi4HRBfoCKkX137tt3sR6HvpnQNcwqg8ARYog,3109\r\njinja2/_stringdefs.py,sha256=SFObWX5vSMeGNc_aSO3_B2EEmScCstFWtjS4K0YFBXk,404291\r\njinja2/bccache.py,sha256=EMN9fsvOpwK3DfxQ9F1lmWoxU2Qlo6AnNhPXTsMrw84,12793\r\njinja2/compiler.py,sha256=nQmoS6HpGwgDIC8UXkSdjPYiAjbVqZ-Gf4odO-SAR6E,63846\r\njinja2/constants.py,sha256=DCr-oKC2xQO-fkOQO3kXRJW7rEYgmcsMRNpPnM66YSU,1626\r\njinja2/debug.py,sha256=GEGHM8vFsNFF-kGc0_fwyj1ftMtuyaH4r0nyG-XA9Z8,11553\r\njinja2/defaults.py,sha256=eLMOE7JC52QwZBu5Gz4TPZqzoJy9IgV5EynL_pW7MUw,1057\r\njinja2/environment.py,sha256=jzJmujSFtxb1HvITO4TdUCOOA-hSZx0gHrxeDZ2VE-M,48120\r\njinja2/exceptions.py,sha256=Q9yZOUif-lhVj5BRw0ELjfBvEdBsB7xZobgOvC2qGy4,4428\r\njinja2/ext.py,sha256=X-1zCiut1cuxIteKPkJr3jb6odlVE1jciO8RnrMniPE,25072\r\njinja2/filters.py,sha256=R4x2flPfyzIjrtItzpGpK4LzBvx-NOlEXH9wD-ZBWtU,30115\r\njinja2/lexer.py,sha256=QyiQwAQVEE2YREZJLcA04F3yqv0XOwBbSlWaFW4xJ20,28425\r\njinja2/loaders.py,sha256=BgDCvmiB0gH_zPMf-6TMemqtJdrck3IyJ8g0kWUvFa0,17380\r\njinja2/meta.py,sha256=cxAOtMuSWWSQX2H8zhYsAtjNwRcNB8Zvs06Y-JlWnbk,4198\r\njinja2/nodes.py,sha256=YN6hfFa0WlfToG2r-Q-yhUkAUp0O9l8KulK53mOAVUo,28954\r\njinja2/optimizer.py,sha256=bNNKbo5SC5FBUm9dvP-I3GkiXZYBYIER7_g9hK77ZVI,2302\r\njinja2/parser.py,sha256=pjLfkZDg2IKJKt_ixNosV-RzwAja5GWYuVeBQumIRns,35442\r\njinja2/runtime.py,sha256=Ct36Q9-gVmKer45syS4j3thQ15T_DnLDh6CqvTcnPwQ,22530\r\njinja2/sandbox.py,sha256=qgH4CoBsF5NwGj0krqsCOw8sg2mXmfpZKnvmZEE-da4,13327\r\njinja2/tests.py,sha256=znB0L_k6wdKp_lQJvxboXwUXDy1HhFe5SSA888tHt_w,4131\r\njinja2/utils.py,sha256=pjbOhQJ5NYexu2MbjA66nBibudUkYcQRZbxvbYE0tFk,16560\r\njinja2/visitor.py,sha256=3hEAYD26xS_JiJBf4RfcqYPpiuR6efOH8Hh6om59eU8,3316\r\nJinja2-2.8.dist-info/DESCRIPTION.rst,sha256=CXIS1UnPSk5_lZBS6Lb8ko-3lqGfjsiUwNBLXCTj2lc,975\r\nJinja2-2.8.dist-info/entry_points.txt,sha256=NdzVcOrqyNyKDxD09aERj__3bFx2paZhizFDsKmVhiA,72\r\nJinja2-2.8.dist-info/METADATA,sha256=Vio5F8qaEVcGzaCV1rl8tIWEKsHUFSSSAfL0u9oMmGk,2061\r\nJinja2-2.8.dist-info/metadata.json,sha256=4TsqsSBwGwy0C2xF_uRZHYsRn2W5Lv4NUMBjTnXPldM,1275\r\nJinja2-2.8.dist-info/RECORD,,\r\nJinja2-2.8.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7\r\nJinja2-2.8.dist-info/WHEEL,sha256=AvR0WeTpDaxT645bl5FQxUK6NPsTls2ttpcGJg3j1Xg,110\r\njinja2/_compat.pyc,,\r\njinja2/sandbox.pyc,,\r\njinja2/_stringdefs.pyc,,\r\njinja2/bccache.pyc,,\r\njinja2/runtime.pyc,,\r\njinja2/utils.pyc,,\r\njinja2/debug.pyc,,\r\njinja2/parser.pyc,,\r\njinja2/defaults.pyc,,\r\njinja2/visitor.pyc,,\r\njinja2/ext.pyc,,\r\njinja2/lexer.pyc,,\r\njinja2/nodes.pyc,,\r\njinja2/environment.pyc,,\r\njinja2/compiler.pyc,,\r\njinja2/exceptions.pyc,,\r\njinja2/__init__.pyc,,\r\njinja2/meta.pyc,,\r\njinja2/loaders.pyc,,\r\njinja2/optimizer.pyc,,\r\njinja2/filters.pyc,,\r\njinja2/tests.pyc,,\r\njinja2/constants.pyc,,\r\n" }, { "path": "lib/Jinja2-2.8.dist-info/WHEEL", "content": "Wheel-Version: 1.0\nGenerator: bdist_wheel (0.24.0)\nRoot-Is-Purelib: true\nTag: py2-none-any\nTag: py3-none-any\n\n" }, { "path": "lib/Jinja2-2.8.dist-info/entry_points.txt", "content": "\n [babel.extractors]\n jinja2 = jinja2.ext:babel_extract[i18n]\n " }, { "path": "lib/Jinja2-2.8.dist-info/metadata.json", "content": "{\"license\": \"BSD\", \"name\": \"Jinja2\", \"metadata_version\": \"2.0\", \"generator\": \"bdist_wheel (0.24.0)\", \"summary\": \"A small but fast and easy to use stand-alone template engine written in pure python.\", \"run_requires\": [{\"requires\": [\"Babel (>=0.8)\"], \"extra\": \"i18n\"}, {\"requires\": [\"MarkupSafe\"]}], \"version\": \"2.8\", \"extensions\": {\"python.details\": {\"project_urls\": {\"Home\": \"http://jinja.pocoo.org/\"}, \"document_names\": {\"description\": \"DESCRIPTION.rst\"}, \"contacts\": [{\"role\": \"author\", \"email\": \"armin.ronacher@active-4.com\", \"name\": \"Armin Ronacher\"}]}, \"python.exports\": {\"babel.extractors\": {\"jinja2\": \"jinja2.ext:babel_extract [i18n]\"}}}, \"classifiers\": [\"Development Status :: 5 - Production/Stable\", \"Environment :: Web Environment\", \"Intended Audience :: Developers\", \"License :: OSI Approved :: BSD License\", \"Operating System :: OS Independent\", \"Programming Language :: Python\", \"Programming Language :: Python :: 2\", \"Programming Language :: Python :: 2.6\", \"Programming Language :: Python :: 2.7\", \"Programming Language :: Python :: 3\", \"Programming Language :: Python :: 3.3\", \"Topic :: Internet :: WWW/HTTP :: Dynamic Content\", \"Topic :: Software Development :: Libraries :: Python Modules\", \"Topic :: Text Processing :: Markup :: HTML\"], \"extras\": [\"i18n\"]}" }, { "path": "lib/Jinja2-2.8.dist-info/top_level.txt", "content": "jinja2\n" }, { "path": "lib/MarkupSafe-0.23.dist-info/DESCRIPTION.rst", "content": "MarkupSafe\n==========\n\nImplements a unicode subclass that supports HTML strings:\n\n>>> from markupsafe import Markup, escape\n>>> escape(\"\")\nMarkup(u'<script>alert(document.cookie);</script>')\n>>> tmpl = Markup(\"%s\")\n>>> tmpl % \"Peter > Lustig\"\nMarkup(u'Peter > Lustig')\n\nIf you want to make an object unicode that is not yet unicode\nbut don't want to lose the taint information, you can use the\n`soft_unicode` function. (On Python 3 you can also use `soft_str` which\nis a different name for the same function).\n\n>>> from markupsafe import soft_unicode\n>>> soft_unicode(42)\nu'42'\n>>> soft_unicode(Markup('foo'))\nMarkup(u'foo')\n\nHTML Representations\n--------------------\n\nObjects can customize their HTML markup equivalent by overriding\nthe `__html__` function:\n\n>>> class Foo(object):\n... def __html__(self):\n... return 'Nice'\n...\n>>> escape(Foo())\nMarkup(u'Nice')\n>>> Markup(Foo())\nMarkup(u'Nice')\n\nSilent Escapes\n--------------\n\nSince MarkupSafe 0.10 there is now also a separate escape function\ncalled `escape_silent` that returns an empty string for `None` for\nconsistency with other systems that return empty strings for `None`\nwhen escaping (for instance Pylons' webhelpers).\n\nIf you also want to use this for the escape method of the Markup\nobject, you can create your own subclass that does that::\n\n from markupsafe import Markup, escape_silent as escape\n\n class SilentMarkup(Markup):\n __slots__ = ()\n\n @classmethod\n def escape(cls, s):\n return cls(escape(s))\n\nNew-Style String Formatting\n---------------------------\n\nStarting with MarkupSafe 0.21 new style string formats from Python 2.6 and\n3.x are now fully supported. Previously the escape behavior of those\nfunctions was spotty at best. The new implementations operates under the\nfollowing algorithm:\n\n1. if an object has an ``__html_format__`` method it is called as\n replacement for ``__format__`` with the format specifier. It either\n has to return a string or markup object.\n2. if an object has an ``__html__`` method it is called.\n3. otherwise the default format system of Python kicks in and the result\n is HTML escaped.\n\nHere is how you can implement your own formatting::\n\n class User(object):\n\n def __init__(self, id, username):\n self.id = id\n self.username = username\n\n def __html_format__(self, format_spec):\n if format_spec == 'link':\n return Markup('{1}').format(\n self.id,\n self.__html__(),\n )\n elif format_spec:\n raise ValueError('Invalid format spec')\n return self.__html__()\n\n def __html__(self):\n return Markup('{0}').format(self.username)\n\nAnd to format that user:\n\n>>> user = User(1, 'foo')\n>>> Markup('

User: {0:link}').format(user)\nMarkup(u'

User: foo')\n\n\n" }, { "path": "lib/MarkupSafe-0.23.dist-info/METADATA", "content": "Metadata-Version: 2.0\nName: MarkupSafe\nVersion: 0.23\nSummary: Implements a XML/HTML/XHTML Markup safe string for Python\nHome-page: http://github.com/mitsuhiko/markupsafe\nAuthor: Armin Ronacher\nAuthor-email: armin.ronacher@active-4.com\nLicense: BSD\nPlatform: UNKNOWN\nClassifier: Development Status :: 5 - Production/Stable\nClassifier: Environment :: Web Environment\nClassifier: Intended Audience :: Developers\nClassifier: License :: OSI Approved :: BSD License\nClassifier: Operating System :: OS Independent\nClassifier: Programming Language :: Python\nClassifier: Programming Language :: Python :: 3\nClassifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content\nClassifier: Topic :: Software Development :: Libraries :: Python Modules\nClassifier: Topic :: Text Processing :: Markup :: HTML\n\nMarkupSafe\n==========\n\nImplements a unicode subclass that supports HTML strings:\n\n>>> from markupsafe import Markup, escape\n>>> escape(\"\")\nMarkup(u'<script>alert(document.cookie);</script>')\n>>> tmpl = Markup(\"%s\")\n>>> tmpl % \"Peter > Lustig\"\nMarkup(u'Peter > Lustig')\n\nIf you want to make an object unicode that is not yet unicode\nbut don't want to lose the taint information, you can use the\n`soft_unicode` function. (On Python 3 you can also use `soft_str` which\nis a different name for the same function).\n\n>>> from markupsafe import soft_unicode\n>>> soft_unicode(42)\nu'42'\n>>> soft_unicode(Markup('foo'))\nMarkup(u'foo')\n\nHTML Representations\n--------------------\n\nObjects can customize their HTML markup equivalent by overriding\nthe `__html__` function:\n\n>>> class Foo(object):\n... def __html__(self):\n... return 'Nice'\n...\n>>> escape(Foo())\nMarkup(u'Nice')\n>>> Markup(Foo())\nMarkup(u'Nice')\n\nSilent Escapes\n--------------\n\nSince MarkupSafe 0.10 there is now also a separate escape function\ncalled `escape_silent` that returns an empty string for `None` for\nconsistency with other systems that return empty strings for `None`\nwhen escaping (for instance Pylons' webhelpers).\n\nIf you also want to use this for the escape method of the Markup\nobject, you can create your own subclass that does that::\n\n from markupsafe import Markup, escape_silent as escape\n\n class SilentMarkup(Markup):\n __slots__ = ()\n\n @classmethod\n def escape(cls, s):\n return cls(escape(s))\n\nNew-Style String Formatting\n---------------------------\n\nStarting with MarkupSafe 0.21 new style string formats from Python 2.6 and\n3.x are now fully supported. Previously the escape behavior of those\nfunctions was spotty at best. The new implementations operates under the\nfollowing algorithm:\n\n1. if an object has an ``__html_format__`` method it is called as\n replacement for ``__format__`` with the format specifier. It either\n has to return a string or markup object.\n2. if an object has an ``__html__`` method it is called.\n3. otherwise the default format system of Python kicks in and the result\n is HTML escaped.\n\nHere is how you can implement your own formatting::\n\n class User(object):\n\n def __init__(self, id, username):\n self.id = id\n self.username = username\n\n def __html_format__(self, format_spec):\n if format_spec == 'link':\n return Markup('{1}').format(\n self.id,\n self.__html__(),\n )\n elif format_spec:\n raise ValueError('Invalid format spec')\n return self.__html__()\n\n def __html__(self):\n return Markup('{0}').format(self.username)\n\nAnd to format that user:\n\n>>> user = User(1, 'foo')\n>>> Markup('

User: {0:link}').format(user)\nMarkup(u'

User: foo')\n\n\n" }, { "path": "lib/MarkupSafe-0.23.dist-info/RECORD", "content": "markupsafe/__init__.py,sha256=zFQpANILi3mCCALiPd6ZJdlW6ibu_hTKzikMXKXVtaM,10338\r\nmarkupsafe/_compat.py,sha256=r1HE0CpcAZeb-AiTV9wITR91PeLHn0CzZ_XHkYoozpI,565\r\nmarkupsafe/_constants.py,sha256=U_xybFQsyXKCgHSfranJnFzo-z9nn9fuBeSk243sE5Q,4795\r\nmarkupsafe/_native.py,sha256=E2Un1ysOf-w45d18YCj8UelT5UP7Vt__IuFPYJ7YRIs,1187\r\nmarkupsafe/_speedups.c,sha256=gZwPEM_0zcbAzJjPuPYXk97R67QR1uUGtDvOPsvirCA,5939\r\nmarkupsafe/_speedups.so,sha256=5LwzbsIbi6XRYL1cFO-TEF5szplVD406i-FXsWCgcPU,26724\r\nmarkupsafe/tests.py,sha256=RLI4eYI0ICNZwkoN638VHXf_fDu4d_jnvbGr22j58Ng,6107\r\nMarkupSafe-0.23.dist-info/DESCRIPTION.rst,sha256=VnEbwPneiOkqh-nzxb0DUiGlcVGHuaDQjsNBLi-yNYw,3091\r\nMarkupSafe-0.23.dist-info/METADATA,sha256=g-KikeSr9J7vagkJoCt0ViT2ORy9O4NYV7XtRu1Pni8,3879\r\nMarkupSafe-0.23.dist-info/metadata.json,sha256=jNrdilCdPfPmCPCQj9EVQSAebHgG8jCtlhqsPMggI4s,901\r\nMarkupSafe-0.23.dist-info/RECORD,,\r\nMarkupSafe-0.23.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11\r\nMarkupSafe-0.23.dist-info/WHEEL,sha256=xNbhRJkOYpM8X1K1ysQX8xjULvydXjcUxM96PNX_KQ8,109\r\nmarkupsafe/_native.pyc,,\r\nmarkupsafe/_constants.pyc,,\r\nmarkupsafe/_compat.pyc,,\r\nmarkupsafe/tests.pyc,,\r\nmarkupsafe/__init__.pyc,,\r\n" }, { "path": "lib/MarkupSafe-0.23.dist-info/WHEEL", "content": "Wheel-Version: 1.0\nGenerator: bdist_wheel (0.24.0)\nRoot-Is-Purelib: false\nTag: cp27-none-macosx_10_10_intel\n\n" }, { "path": "lib/MarkupSafe-0.23.dist-info/metadata.json", "content": "{\"summary\": \"Implements a XML/HTML/XHTML Markup safe string for Python\", \"metadata_version\": \"2.0\", \"license\": \"BSD\", \"extensions\": {\"python.details\": {\"project_urls\": {\"Home\": \"http://github.com/mitsuhiko/markupsafe\"}, \"contacts\": [{\"role\": \"author\", \"email\": \"armin.ronacher@active-4.com\", \"name\": \"Armin Ronacher\"}], \"document_names\": {\"description\": \"DESCRIPTION.rst\"}}}, \"generator\": \"bdist_wheel (0.24.0)\", \"classifiers\": [\"Development Status :: 5 - Production/Stable\", \"Environment :: Web Environment\", \"Intended Audience :: Developers\", \"License :: OSI Approved :: BSD License\", \"Operating System :: OS Independent\", \"Programming Language :: Python\", \"Programming Language :: Python :: 3\", \"Topic :: Internet :: WWW/HTTP :: Dynamic Content\", \"Topic :: Software Development :: Libraries :: Python Modules\", \"Topic :: Text Processing :: Markup :: HTML\"], \"version\": \"0.23\", \"name\": \"MarkupSafe\"}" }, { "path": "lib/MarkupSafe-0.23.dist-info/top_level.txt", "content": "markupsafe\n" }, { "path": "lib/README.md", "content": "This directory contains third-party dependencies installed with `pip`." }, { "path": "lib/Werkzeug-0.11.dist-info/DESCRIPTION.rst", "content": "Werkzeug\n========\n\nWerkzeug started as simple collection of various utilities for WSGI\napplications and has become one of the most advanced WSGI utility\nmodules. It includes a powerful debugger, full featured request and\nresponse objects, HTTP utilities to handle entity tags, cache control\nheaders, HTTP dates, cookie handling, file uploads, a powerful URL\nrouting system and a bunch of community contributed addon modules.\n\nWerkzeug is unicode aware and doesn't enforce a specific template\nengine, database adapter or anything else. It doesn't even enforce\na specific way of handling requests and leaves all that up to the\ndeveloper. It's most useful for end user applications which should work\non as many server environments as possible (such as blogs, wikis,\nbulletin boards, etc.).\n\nDetails and example applications are available on the\n`Werkzeug website `_.\n\n\nFeatures\n--------\n\n- unicode awareness\n\n- request and response objects\n\n- various utility functions for dealing with HTTP headers such as\n `Accept` and `Cache-Control` headers.\n\n- thread local objects with proper cleanup at request end\n\n- an interactive debugger\n\n- A simple WSGI server with support for threading and forking\n with an automatic reloader.\n\n- a flexible URL routing system with REST support.\n\n- fully WSGI compatible\n\n\nDevelopment Version\n-------------------\n\nThe Werkzeug development version can be installed by cloning the git\nrepository from `github`_::\n\n git clone git@github.com:mitsuhiko/werkzeug.git\n\n.. _github: http://github.com/mitsuhiko/werkzeug\n\n\n" }, { "path": "lib/Werkzeug-0.11.dist-info/METADATA", "content": "Metadata-Version: 2.0\nName: Werkzeug\nVersion: 0.11\nSummary: The Swiss Army knife of Python web development\nHome-page: http://werkzeug.pocoo.org/\nAuthor: Armin Ronacher\nAuthor-email: armin.ronacher@active-4.com\nLicense: BSD\nPlatform: any\nClassifier: Development Status :: 5 - Production/Stable\nClassifier: Environment :: Web Environment\nClassifier: Intended Audience :: Developers\nClassifier: License :: OSI Approved :: BSD License\nClassifier: Operating System :: OS Independent\nClassifier: Programming Language :: Python\nClassifier: Programming Language :: Python :: 2\nClassifier: Programming Language :: Python :: 2.6\nClassifier: Programming Language :: Python :: 2.7\nClassifier: Programming Language :: Python :: 3\nClassifier: Programming Language :: Python :: 3.3\nClassifier: Programming Language :: Python :: 3.4\nClassifier: Programming Language :: Python :: 3.5\nClassifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content\nClassifier: Topic :: Software Development :: Libraries :: Python Modules\n\nWerkzeug\n========\n\nWerkzeug started as simple collection of various utilities for WSGI\napplications and has become one of the most advanced WSGI utility\nmodules. It includes a powerful debugger, full featured request and\nresponse objects, HTTP utilities to handle entity tags, cache control\nheaders, HTTP dates, cookie handling, file uploads, a powerful URL\nrouting system and a bunch of community contributed addon modules.\n\nWerkzeug is unicode aware and doesn't enforce a specific template\nengine, database adapter or anything else. It doesn't even enforce\na specific way of handling requests and leaves all that up to the\ndeveloper. It's most useful for end user applications which should work\non as many server environments as possible (such as blogs, wikis,\nbulletin boards, etc.).\n\nDetails and example applications are available on the\n`Werkzeug website `_.\n\n\nFeatures\n--------\n\n- unicode awareness\n\n- request and response objects\n\n- various utility functions for dealing with HTTP headers such as\n `Accept` and `Cache-Control` headers.\n\n- thread local objects with proper cleanup at request end\n\n- an interactive debugger\n\n- A simple WSGI server with support for threading and forking\n with an automatic reloader.\n\n- a flexible URL routing system with REST support.\n\n- fully WSGI compatible\n\n\nDevelopment Version\n-------------------\n\nThe Werkzeug development version can be installed by cloning the git\nrepository from `github`_::\n\n git clone git@github.com:mitsuhiko/werkzeug.git\n\n.. _github: http://github.com/mitsuhiko/werkzeug\n\n\n" }, { "path": "lib/Werkzeug-0.11.dist-info/RECORD", "content": "Werkzeug-0.11.dist-info/DESCRIPTION.rst,sha256=5sTwZ_Sj5aeEN8mlcOdNJ_ng40HiGazGmILLyTMX8o0,1595\r\nWerkzeug-0.11.dist-info/METADATA,sha256=QX9osuhRKD2M0jRKGyVmOASL5y3INKSLtA4d0GSpsbM,2597\r\nWerkzeug-0.11.dist-info/RECORD,,\r\nWerkzeug-0.11.dist-info/WHEEL,sha256=GrqQvamwgBV4nLoJe0vhYRSWzWsx7xjlt74FT0SWYfE,110\r\nWerkzeug-0.11.dist-info/metadata.json,sha256=3rlxBTLVZ6cqm8wuS4n6ZgpoywLEfrpXWVahLNaFoVM,1093\r\nWerkzeug-0.11.dist-info/top_level.txt,sha256=QRyj2VjwJoQkrwjwFIOlB8Xg3r9un0NtqVHQF-15xaw,9\r\nwerkzeug/__init__.py,sha256=Nf_xs5zUQajNujPuiuiFWoGok3W9fmC-7BHJy8-2pok,6917\r\nwerkzeug/_compat.py,sha256=8c4U9o6A_TR9nKCcTbpZNxpqCXcXDVIbFawwKM2s92c,6311\r\nwerkzeug/_internal.py,sha256=IEScSoFtQ8KqFH_2ubdfscNAdQ2RIysyVupI5BR9W2U,13709\r\nwerkzeug/_reloader.py,sha256=glTJPAR6qz3hLYw7xsANeNlEvgEf_WeU2cTz66rUqK8,8548\r\nwerkzeug/datastructures.py,sha256=iQ4TqWXdHSXtL5srpP8t-6bEJEiKDkfiI8lHOl_A_kU,87447\r\nwerkzeug/exceptions.py,sha256=X7D6bNqLmXfftc-6kuifVGFaxngHbMm8QD4DSZ7K5vA,18609\r\nwerkzeug/filesystem.py,sha256=0_gjAftvnRBxoD6ZCssJDJztUjprsLC97eC_k4YRdXs,2174\r\nwerkzeug/formparser.py,sha256=ndLQxfmq-IeNUlee30WHfxq1YggzSO1l7QGeeFVr99M,21207\r\nwerkzeug/http.py,sha256=I4yzJHGnsaMW7kZQcWzNW9H7ijXT_iPR16jbN3jejVY,35031\r\nwerkzeug/local.py,sha256=vWF4ECvkbXoOWM4BThsU5qEzC2LwdiEn7WA-qEt8pvg,14123\r\nwerkzeug/posixemulation.py,sha256=xEF2Bxc-vUCPkiu4IbfWVd3LW7DROYAT-ExW6THqyzw,3519\r\nwerkzeug/routing.py,sha256=U6d5l9iRrntZXkhr-GFQUmz9KBM_YKSr1oVSB9Ppv5k,66260\r\nwerkzeug/script.py,sha256=DwaVDcXdaOTffdNvlBdLitxWXjKaRVT32VbhDtljFPY,11365\r\nwerkzeug/security.py,sha256=tuVc22OqoHV5K-TrYJmynCJJa12aUt9BQ3wR_vEPQ34,8971\r\nwerkzeug/serving.py,sha256=Jf2GLYlXLkVBShH4x3rHKdNBGNjT2pZHStSP0-1wF5Y,27228\r\nwerkzeug/test.py,sha256=nan0aDi3g5hyUzWCtaN3XL9HrbIsNNNgMNjwpfM6qMc,34152\r\nwerkzeug/testapp.py,sha256=3HQRW1sHZKXuAjCvFMet4KXtQG3loYTFnvn6LWt-4zI,9396\r\nwerkzeug/urls.py,sha256=xhJoL81fOOWH2W0MReJKW2-KoR0b3p4zYkcvqylw254,36634\r\nwerkzeug/useragents.py,sha256=uqpgPcJ5BfcCVh9nPIIl2r3duIrIuENmrbRqbAMmPDk,5418\r\nwerkzeug/utils.py,sha256=lkybtv_mq35zV1qhelvEcILTzrMUwZ9yon6E8XwapJE,22972\r\nwerkzeug/wrappers.py,sha256=lKYevpKD1-quk9Cop7bsFxt1eWJxU3h33HCnOI_YzSU,77011\r\nwerkzeug/wsgi.py,sha256=CP-hCwH8te4cFz1bzWJoITJ5j-7E4j55fBkmuyp8xvc,37881\r\nwerkzeug/contrib/__init__.py,sha256=f7PfttZhbrImqpr5Ezre8CXgwvcGUJK7zWNpO34WWrw,623\r\nwerkzeug/contrib/atom.py,sha256=rvijBrphjMzVObfuCR6ddu6aLwI_SiNiudu64OSTh4Q,15588\r\nwerkzeug/contrib/cache.py,sha256=4W2WCT9Hw6HEU8yME9GuU4Xf8e50r2K84ASMxhLb6tY,27983\r\nwerkzeug/contrib/fixers.py,sha256=MtN_YmENxoTsGvXGGERmtbQ62LaeFc5I2d1YifXNENA,10183\r\nwerkzeug/contrib/iterio.py,sha256=pTX36rYCKO_9IEoB5sIN5cFSYszI9zdx6YhquWovcPY,10814\r\nwerkzeug/contrib/jsrouting.py,sha256=QTmgeDoKXvNK02KzXgx9lr3cAH6fAzpwF5bBdPNvJPs,8564\r\nwerkzeug/contrib/limiter.py,sha256=iS8-ahPZ-JLRnmfIBzxpm7O_s3lPsiDMVWv7llAIDCI,1334\r\nwerkzeug/contrib/lint.py,sha256=UxVVvYwnKa5BqYJdgfAzNc2w834OKgguvN-wg8E1Dhc,12322\r\nwerkzeug/contrib/profiler.py,sha256=ISwCWvwVyGpDLRBRpLjo_qUWma6GXYBrTAco4PEQSHY,5151\r\nwerkzeug/contrib/securecookie.py,sha256=X-Ao_0NRDveW6K1Fhe4U42hHWBW8esCpA3VcBDpzWIk,12206\r\nwerkzeug/contrib/sessions.py,sha256=uAPcnyxaxEla-bUA13gKc3KK4mwSagdzbCZzyKl3PeE,12577\r\nwerkzeug/contrib/testtools.py,sha256=G9xN-qeihJlhExrIZMCahvQOIDxdL9NiX874jiiHFMs,2453\r\nwerkzeug/contrib/wrappers.py,sha256=Uv5FRO5OqKwOsNgkW2-FRcw0vUDe3uiaivjPNYWNfAk,10337\r\nwerkzeug/debug/__init__.py,sha256=GDFrgOvwQ5wXQ2q5EeVBKh6JUQS8zLFFkgY6UOWeKrs,13126\r\nwerkzeug/debug/console.py,sha256=B7uAu9Rk60siDnGlEt-A_q1ZR4zCtmxx5itg3X-BOxo,5599\r\nwerkzeug/debug/repr.py,sha256=NaoB89aHb0vuvdSWels-GWdeGDZp76uE4uSNZPX1jAM,9354\r\nwerkzeug/debug/tbtools.py,sha256=L5P5TkGEHc_Bc5duNosP6D4CNe7ieTo1oiPX8nKQdek,18402\r\nwerkzeug/debug/shared/FONT_LICENSE,sha256=LwAVEI1oYnvXiNMT9SnCH_TaLCxCpeHziDrMg0gPkAI,4673\r\nwerkzeug/debug/shared/console.png,sha256=bxax6RXXlvOij_KeqvSNX0ojJf83YbnZ7my-3Gx9w2A,507\r\nwerkzeug/debug/shared/debugger.js,sha256=PEMBoNuD6fUaNou8Km_ZvVmFcIA3z3k3jSEMWLW-cA0,6187\r\nwerkzeug/debug/shared/jquery.js,sha256=7LkWEzqTdpEfELxcZZlS6wAx5Ff13zZ83lYO2_ujj7g,95957\r\nwerkzeug/debug/shared/less.png,sha256=-4-kNRaXJSONVLahrQKUxMwXGm9R4OnZ9SxDGpHlIR4,191\r\nwerkzeug/debug/shared/more.png,sha256=GngN7CioHQoV58rH6ojnkYi8c_qED2Aka5FO5UXrReY,200\r\nwerkzeug/debug/shared/source.png,sha256=RoGcBTE4CyCB85GBuDGTFlAnUqxwTBiIfDqW15EpnUQ,818\r\nwerkzeug/debug/shared/style.css,sha256=7x1s8olZO1XHalqD4M9MWn9vRqQkA635S9_6zRoe220,6231\r\nwerkzeug/debug/shared/ubuntu.ttf,sha256=1eaHFyepmy4FyDvjLVzpITrGEBu_CZYY94jE0nED1c0,70220\r\nwerkzeug/_reloader.pyc,,\r\nwerkzeug/filesystem.pyc,,\r\nwerkzeug/contrib/testtools.pyc,,\r\nwerkzeug/formparser.pyc,,\r\nwerkzeug/_compat.pyc,,\r\nwerkzeug/posixemulation.pyc,,\r\nwerkzeug/serving.pyc,,\r\nwerkzeug/contrib/__init__.pyc,,\r\nwerkzeug/contrib/iterio.pyc,,\r\nwerkzeug/datastructures.pyc,,\r\nwerkzeug/__init__.pyc,,\r\nwerkzeug/contrib/limiter.pyc,,\r\nwerkzeug/debug/tbtools.pyc,,\r\nwerkzeug/contrib/sessions.pyc,,\r\nwerkzeug/local.pyc,,\r\nwerkzeug/utils.pyc,,\r\nwerkzeug/contrib/lint.pyc,,\r\nwerkzeug/security.pyc,,\r\nwerkzeug/contrib/cache.pyc,,\r\nwerkzeug/contrib/securecookie.pyc,,\r\nwerkzeug/script.pyc,,\r\nwerkzeug/routing.pyc,,\r\nwerkzeug/wrappers.pyc,,\r\nwerkzeug/contrib/jsrouting.pyc,,\r\nwerkzeug/contrib/fixers.pyc,,\r\nwerkzeug/contrib/profiler.pyc,,\r\nwerkzeug/debug/console.pyc,,\r\nwerkzeug/debug/__init__.pyc,,\r\nwerkzeug/wsgi.pyc,,\r\nwerkzeug/test.pyc,,\r\nwerkzeug/http.pyc,,\r\nwerkzeug/urls.pyc,,\r\nwerkzeug/useragents.pyc,,\r\nwerkzeug/_internal.pyc,,\r\nwerkzeug/contrib/wrappers.pyc,,\r\nwerkzeug/exceptions.pyc,,\r\nwerkzeug/contrib/atom.pyc,,\r\nwerkzeug/testapp.pyc,,\r\nwerkzeug/debug/repr.pyc,,\r\n" }, { "path": "lib/Werkzeug-0.11.dist-info/WHEEL", "content": "Wheel-Version: 1.0\nGenerator: bdist_wheel (0.26.0)\nRoot-Is-Purelib: true\nTag: py2-none-any\nTag: py3-none-any\n\n" }, { "path": "lib/Werkzeug-0.11.dist-info/metadata.json", "content": "{\"generator\": \"bdist_wheel (0.26.0)\", \"summary\": \"The Swiss Army knife of Python web development\", \"classifiers\": [\"Development Status :: 5 - Production/Stable\", \"Environment :: Web Environment\", \"Intended Audience :: Developers\", \"License :: OSI Approved :: BSD License\", \"Operating System :: OS Independent\", \"Programming Language :: Python\", \"Programming Language :: Python :: 2\", \"Programming Language :: Python :: 2.6\", \"Programming Language :: Python :: 2.7\", \"Programming Language :: Python :: 3\", \"Programming Language :: Python :: 3.3\", \"Programming Language :: Python :: 3.4\", \"Programming Language :: Python :: 3.5\", \"Topic :: Internet :: WWW/HTTP :: Dynamic Content\", \"Topic :: Software Development :: Libraries :: Python Modules\"], \"extensions\": {\"python.details\": {\"project_urls\": {\"Home\": \"http://werkzeug.pocoo.org/\"}, \"contacts\": [{\"email\": \"armin.ronacher@active-4.com\", \"name\": \"Armin Ronacher\", \"role\": \"author\"}], \"document_names\": {\"description\": \"DESCRIPTION.rst\"}}}, \"license\": \"BSD\", \"metadata_version\": \"2.0\", \"name\": \"Werkzeug\", \"platform\": \"any\", \"version\": \"0.11\"}" }, { "path": "lib/Werkzeug-0.11.dist-info/top_level.txt", "content": "werkzeug\n" }, { "path": "lib/flask/__init__.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask\n ~~~~~\n\n A microframework based on Werkzeug. It's extensively documented\n and follows best practice patterns.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\n__version__ = '0.10'\n\n# utilities we import from Werkzeug and Jinja2 that are unused\n# in the module but are exported as public interface.\nfrom werkzeug.exceptions import abort\nfrom werkzeug.utils import redirect\nfrom jinja2 import Markup, escape\n\nfrom .app import Flask, Request, Response\nfrom .config import Config\nfrom .helpers import url_for, flash, send_file, send_from_directory, \\\n get_flashed_messages, get_template_attribute, make_response, safe_join, \\\n stream_with_context\nfrom .globals import current_app, g, request, session, _request_ctx_stack, \\\n _app_ctx_stack\nfrom .ctx import has_request_context, has_app_context, \\\n after_this_request, copy_current_request_context\nfrom .module import Module\nfrom .blueprints import Blueprint\nfrom .templating import render_template, render_template_string\n\n# the signals\nfrom .signals import signals_available, template_rendered, request_started, \\\n request_finished, got_request_exception, request_tearing_down, \\\n appcontext_tearing_down, appcontext_pushed, \\\n appcontext_popped, message_flashed\n\n# We're not exposing the actual json module but a convenient wrapper around\n# it.\nfrom . import json\n\n# This was the only thing that flask used to export at one point and it had\n# a more generic name.\njsonify = json.jsonify\n\n# backwards compat, goes away in 1.0\nfrom .sessions import SecureCookieSession as Session\njson_available = True\n" }, { "path": "lib/flask/_compat.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask._compat\n ~~~~~~~~~~~~~\n\n Some py2/py3 compatibility support based on a stripped down\n version of six so we don't have to depend on a specific version\n of it.\n\n :copyright: (c) 2013 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nimport sys\n\nPY2 = sys.version_info[0] == 2\n_identity = lambda x: x\n\n\nif not PY2:\n text_type = str\n string_types = (str,)\n integer_types = (int, )\n\n iterkeys = lambda d: iter(d.keys())\n itervalues = lambda d: iter(d.values())\n iteritems = lambda d: iter(d.items())\n\n from io import StringIO\n\n def reraise(tp, value, tb=None):\n if value.__traceback__ is not tb:\n raise value.with_traceback(tb)\n raise value\n\n implements_to_string = _identity\n\nelse:\n text_type = unicode\n string_types = (str, unicode)\n integer_types = (int, long)\n\n iterkeys = lambda d: d.iterkeys()\n itervalues = lambda d: d.itervalues()\n iteritems = lambda d: d.iteritems()\n\n from cStringIO import StringIO\n\n exec('def reraise(tp, value, tb=None):\\n raise tp, value, tb')\n\n def implements_to_string(cls):\n cls.__unicode__ = cls.__str__\n cls.__str__ = lambda x: x.__unicode__().encode('utf-8')\n return cls\n\n\ndef with_metaclass(meta, *bases):\n # This requires a bit of explanation: the basic idea is to make a\n # dummy metaclass for one level of class instantiation that replaces\n # itself with the actual metaclass. Because of internal type checks\n # we also need to make sure that we downgrade the custom metaclass\n # for one level to something closer to type (that's why __call__ and\n # __init__ comes back from type etc.).\n #\n # This has the advantage over six.with_metaclass in that it does not\n # introduce dummy classes into the final MRO.\n class metaclass(meta):\n __call__ = type.__call__\n __init__ = type.__init__\n def __new__(cls, name, this_bases, d):\n if this_bases is None:\n return type.__new__(cls, name, (), d)\n return meta(name, bases, d)\n return metaclass('temporary_class', None, {})\n" }, { "path": "lib/flask/app.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.app\n ~~~~~~~~~\n\n This module implements the central WSGI application object.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\nimport os\nimport sys\nfrom threading import Lock\nfrom datetime import timedelta\nfrom itertools import chain\nfrom functools import update_wrapper\n\nfrom werkzeug.datastructures import ImmutableDict\nfrom werkzeug.routing import Map, Rule, RequestRedirect, BuildError\nfrom werkzeug.exceptions import HTTPException, InternalServerError, \\\n MethodNotAllowed, BadRequest\n\nfrom .helpers import _PackageBoundObject, url_for, get_flashed_messages, \\\n locked_cached_property, _endpoint_from_view_func, find_package\nfrom . import json\nfrom .wrappers import Request, Response\nfrom .config import ConfigAttribute, Config\nfrom .ctx import RequestContext, AppContext, _AppCtxGlobals\nfrom .globals import _request_ctx_stack, request, session, g\nfrom .sessions import SecureCookieSessionInterface\nfrom .module import blueprint_is_module\nfrom .templating import DispatchingJinjaLoader, Environment, \\\n _default_template_ctx_processor\nfrom .signals import request_started, request_finished, got_request_exception, \\\n request_tearing_down, appcontext_tearing_down\nfrom ._compat import reraise, string_types, text_type, integer_types\n\n# a lock used for logger initialization\n_logger_lock = Lock()\n\n\ndef _make_timedelta(value):\n if not isinstance(value, timedelta):\n return timedelta(seconds=value)\n return value\n\n\ndef setupmethod(f):\n \"\"\"Wraps a method so that it performs a check in debug mode if the\n first request was already handled.\n \"\"\"\n def wrapper_func(self, *args, **kwargs):\n if self.debug and self._got_first_request:\n raise AssertionError('A setup function was called after the '\n 'first request was handled. This usually indicates a bug '\n 'in the application where a module was not imported '\n 'and decorators or other functionality was called too late.\\n'\n 'To fix this make sure to import all your view modules, '\n 'database models and everything related at a central place '\n 'before the application starts serving requests.')\n return f(self, *args, **kwargs)\n return update_wrapper(wrapper_func, f)\n\n\nclass Flask(_PackageBoundObject):\n \"\"\"The flask object implements a WSGI application and acts as the central\n object. It is passed the name of the module or package of the\n application. Once it is created it will act as a central registry for\n the view functions, the URL rules, template configuration and much more.\n\n The name of the package is used to resolve resources from inside the\n package or the folder the module is contained in depending on if the\n package parameter resolves to an actual python package (a folder with\n an `__init__.py` file inside) or a standard module (just a `.py` file).\n\n For more information about resource loading, see :func:`open_resource`.\n\n Usually you create a :class:`Flask` instance in your main module or\n in the `__init__.py` file of your package like this::\n\n from flask import Flask\n app = Flask(__name__)\n\n .. admonition:: About the First Parameter\n\n The idea of the first parameter is to give Flask an idea what\n belongs to your application. This name is used to find resources\n on the file system, can be used by extensions to improve debugging\n information and a lot more.\n\n So it's important what you provide there. If you are using a single\n module, `__name__` is always the correct value. If you however are\n using a package, it's usually recommended to hardcode the name of\n your package there.\n\n For example if your application is defined in `yourapplication/app.py`\n you should create it with one of the two versions below::\n\n app = Flask('yourapplication')\n app = Flask(__name__.split('.')[0])\n\n Why is that? The application will work even with `__name__`, thanks\n to how resources are looked up. However it will make debugging more\n painful. Certain extensions can make assumptions based on the\n import name of your application. For example the Flask-SQLAlchemy\n extension will look for the code in your application that triggered\n an SQL query in debug mode. If the import name is not properly set\n up, that debugging information is lost. (For example it would only\n pick up SQL queries in `yourapplication.app` and not\n `yourapplication.views.frontend`)\n\n .. versionadded:: 0.7\n The `static_url_path`, `static_folder`, and `template_folder`\n parameters were added.\n\n .. versionadded:: 0.8\n The `instance_path` and `instance_relative_config` parameters were\n added.\n\n :param import_name: the name of the application package\n :param static_url_path: can be used to specify a different path for the\n static files on the web. Defaults to the name\n of the `static_folder` folder.\n :param static_folder: the folder with static files that should be served\n at `static_url_path`. Defaults to the ``'static'``\n folder in the root path of the application.\n :param template_folder: the folder that contains the templates that should\n be used by the application. Defaults to\n ``'templates'`` folder in the root path of the\n application.\n :param instance_path: An alternative instance path for the application.\n By default the folder ``'instance'`` next to the\n package or module is assumed to be the instance\n path.\n :param instance_relative_config: if set to `True` relative filenames\n for loading the config are assumed to\n be relative to the instance path instead\n of the application root.\n \"\"\"\n\n #: The class that is used for request objects. See :class:`~flask.Request`\n #: for more information.\n request_class = Request\n\n #: The class that is used for response objects. See\n #: :class:`~flask.Response` for more information.\n response_class = Response\n\n #: The class that is used for the :data:`~flask.g` instance.\n #:\n #: Example use cases for a custom class:\n #:\n #: 1. Store arbitrary attributes on flask.g.\n #: 2. Add a property for lazy per-request database connectors.\n #: 3. Return None instead of AttributeError on expected attributes.\n #: 4. Raise exception if an unexpected attr is set, a \"controlled\" flask.g.\n #:\n #: In Flask 0.9 this property was called `request_globals_class` but it\n #: was changed in 0.10 to :attr:`app_ctx_globals_class` because the\n #: flask.g object is not application context scoped.\n #:\n #: .. versionadded:: 0.10\n app_ctx_globals_class = _AppCtxGlobals\n\n # Backwards compatibility support\n def _get_request_globals_class(self):\n return self.app_ctx_globals_class\n def _set_request_globals_class(self, value):\n from warnings import warn\n warn(DeprecationWarning('request_globals_class attribute is now '\n 'called app_ctx_globals_class'))\n self.app_ctx_globals_class = value\n request_globals_class = property(_get_request_globals_class,\n _set_request_globals_class)\n del _get_request_globals_class, _set_request_globals_class\n\n #: The debug flag. Set this to `True` to enable debugging of the\n #: application. In debug mode the debugger will kick in when an unhandled\n #: exception occurs and the integrated server will automatically reload\n #: the application if changes in the code are detected.\n #:\n #: This attribute can also be configured from the config with the `DEBUG`\n #: configuration key. Defaults to `False`.\n debug = ConfigAttribute('DEBUG')\n\n #: The testing flag. Set this to `True` to enable the test mode of\n #: Flask extensions (and in the future probably also Flask itself).\n #: For example this might activate unittest helpers that have an\n #: additional runtime cost which should not be enabled by default.\n #:\n #: If this is enabled and PROPAGATE_EXCEPTIONS is not changed from the\n #: default it's implicitly enabled.\n #:\n #: This attribute can also be configured from the config with the\n #: `TESTING` configuration key. Defaults to `False`.\n testing = ConfigAttribute('TESTING')\n\n #: If a secret key is set, cryptographic components can use this to\n #: sign cookies and other things. Set this to a complex random value\n #: when you want to use the secure cookie for instance.\n #:\n #: This attribute can also be configured from the config with the\n #: `SECRET_KEY` configuration key. Defaults to `None`.\n secret_key = ConfigAttribute('SECRET_KEY')\n\n #: The secure cookie uses this for the name of the session cookie.\n #:\n #: This attribute can also be configured from the config with the\n #: `SESSION_COOKIE_NAME` configuration key. Defaults to ``'session'``\n session_cookie_name = ConfigAttribute('SESSION_COOKIE_NAME')\n\n #: A :class:`~datetime.timedelta` which is used to set the expiration\n #: date of a permanent session. The default is 31 days which makes a\n #: permanent session survive for roughly one month.\n #:\n #: This attribute can also be configured from the config with the\n #: `PERMANENT_SESSION_LIFETIME` configuration key. Defaults to\n #: ``timedelta(days=31)``\n permanent_session_lifetime = ConfigAttribute('PERMANENT_SESSION_LIFETIME',\n get_converter=_make_timedelta)\n\n #: Enable this if you want to use the X-Sendfile feature. Keep in\n #: mind that the server has to support this. This only affects files\n #: sent with the :func:`send_file` method.\n #:\n #: .. versionadded:: 0.2\n #:\n #: This attribute can also be configured from the config with the\n #: `USE_X_SENDFILE` configuration key. Defaults to `False`.\n use_x_sendfile = ConfigAttribute('USE_X_SENDFILE')\n\n #: The name of the logger to use. By default the logger name is the\n #: package name passed to the constructor.\n #:\n #: .. versionadded:: 0.4\n logger_name = ConfigAttribute('LOGGER_NAME')\n\n #: Enable the deprecated module support? This is active by default\n #: in 0.7 but will be changed to False in 0.8. With Flask 1.0 modules\n #: will be removed in favor of Blueprints\n enable_modules = True\n\n #: The logging format used for the debug logger. This is only used when\n #: the application is in debug mode, otherwise the attached logging\n #: handler does the formatting.\n #:\n #: .. versionadded:: 0.3\n debug_log_format = (\n '-' * 80 + '\\n' +\n '%(levelname)s in %(module)s [%(pathname)s:%(lineno)d]:\\n' +\n '%(message)s\\n' +\n '-' * 80\n )\n\n #: The JSON encoder class to use. Defaults to :class:`~flask.json.JSONEncoder`.\n #:\n #: .. versionadded:: 0.10\n json_encoder = json.JSONEncoder\n\n #: The JSON decoder class to use. Defaults to :class:`~flask.json.JSONDecoder`.\n #:\n #: .. versionadded:: 0.10\n json_decoder = json.JSONDecoder\n\n #: Options that are passed directly to the Jinja2 environment.\n jinja_options = ImmutableDict(\n extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_']\n )\n\n #: Default configuration parameters.\n default_config = ImmutableDict({\n 'DEBUG': False,\n 'TESTING': False,\n 'PROPAGATE_EXCEPTIONS': None,\n 'PRESERVE_CONTEXT_ON_EXCEPTION': None,\n 'SECRET_KEY': None,\n 'PERMANENT_SESSION_LIFETIME': timedelta(days=31),\n 'USE_X_SENDFILE': False,\n 'LOGGER_NAME': None,\n 'SERVER_NAME': None,\n 'APPLICATION_ROOT': None,\n 'SESSION_COOKIE_NAME': 'session',\n 'SESSION_COOKIE_DOMAIN': None,\n 'SESSION_COOKIE_PATH': None,\n 'SESSION_COOKIE_HTTPONLY': True,\n 'SESSION_COOKIE_SECURE': False,\n 'MAX_CONTENT_LENGTH': None,\n 'SEND_FILE_MAX_AGE_DEFAULT': 12 * 60 * 60, # 12 hours\n 'TRAP_BAD_REQUEST_ERRORS': False,\n 'TRAP_HTTP_EXCEPTIONS': False,\n 'PREFERRED_URL_SCHEME': 'http',\n 'JSON_AS_ASCII': True,\n 'JSON_SORT_KEYS': True,\n 'JSONIFY_PRETTYPRINT_REGULAR': True,\n })\n\n #: The rule object to use for URL rules created. This is used by\n #: :meth:`add_url_rule`. Defaults to :class:`werkzeug.routing.Rule`.\n #:\n #: .. versionadded:: 0.7\n url_rule_class = Rule\n\n #: the test client that is used with when `test_client` is used.\n #:\n #: .. versionadded:: 0.7\n test_client_class = None\n\n #: the session interface to use. By default an instance of\n #: :class:`~flask.sessions.SecureCookieSessionInterface` is used here.\n #:\n #: .. versionadded:: 0.8\n session_interface = SecureCookieSessionInterface()\n\n def __init__(self, import_name, static_path=None, static_url_path=None,\n static_folder='static', template_folder='templates',\n instance_path=None, instance_relative_config=False):\n _PackageBoundObject.__init__(self, import_name,\n template_folder=template_folder)\n if static_path is not None:\n from warnings import warn\n warn(DeprecationWarning('static_path is now called '\n 'static_url_path'), stacklevel=2)\n static_url_path = static_path\n\n if static_url_path is not None:\n self.static_url_path = static_url_path\n if static_folder is not None:\n self.static_folder = static_folder\n if instance_path is None:\n instance_path = self.auto_find_instance_path()\n elif not os.path.isabs(instance_path):\n raise ValueError('If an instance path is provided it must be '\n 'absolute. A relative path was given instead.')\n\n #: Holds the path to the instance folder.\n #:\n #: .. versionadded:: 0.8\n self.instance_path = instance_path\n\n #: The configuration dictionary as :class:`Config`. This behaves\n #: exactly like a regular dictionary but supports additional methods\n #: to load a config from files.\n self.config = self.make_config(instance_relative_config)\n\n # Prepare the deferred setup of the logger.\n self._logger = None\n self.logger_name = self.import_name\n\n #: A dictionary of all view functions registered. The keys will\n #: be function names which are also used to generate URLs and\n #: the values are the function objects themselves.\n #: To register a view function, use the :meth:`route` decorator.\n self.view_functions = {}\n\n # support for the now deprecated `error_handlers` attribute. The\n # :attr:`error_handler_spec` shall be used now.\n self._error_handlers = {}\n\n #: A dictionary of all registered error handlers. The key is `None`\n #: for error handlers active on the application, otherwise the key is\n #: the name of the blueprint. Each key points to another dictionary\n #: where they key is the status code of the http exception. The\n #: special key `None` points to a list of tuples where the first item\n #: is the class for the instance check and the second the error handler\n #: function.\n #:\n #: To register a error handler, use the :meth:`errorhandler`\n #: decorator.\n self.error_handler_spec = {None: self._error_handlers}\n\n #: A list of functions that are called when :meth:`url_for` raises a\n #: :exc:`~werkzeug.routing.BuildError`. Each function registered here\n #: is called with `error`, `endpoint` and `values`. If a function\n #: returns `None` or raises a `BuildError` the next function is\n #: tried.\n #:\n #: .. versionadded:: 0.9\n self.url_build_error_handlers = []\n\n #: A dictionary with lists of functions that should be called at the\n #: beginning of the request. The key of the dictionary is the name of\n #: the blueprint this function is active for, `None` for all requests.\n #: This can for example be used to open database connections or\n #: getting hold of the currently logged in user. To register a\n #: function here, use the :meth:`before_request` decorator.\n self.before_request_funcs = {}\n\n #: A lists of functions that should be called at the beginning of the\n #: first request to this instance. To register a function here, use\n #: the :meth:`before_first_request` decorator.\n #:\n #: .. versionadded:: 0.8\n self.before_first_request_funcs = []\n\n #: A dictionary with lists of functions that should be called after\n #: each request. The key of the dictionary is the name of the blueprint\n #: this function is active for, `None` for all requests. This can for\n #: example be used to open database connections or getting hold of the\n #: currently logged in user. To register a function here, use the\n #: :meth:`after_request` decorator.\n self.after_request_funcs = {}\n\n #: A dictionary with lists of functions that are called after\n #: each request, even if an exception has occurred. The key of the\n #: dictionary is the name of the blueprint this function is active for,\n #: `None` for all requests. These functions are not allowed to modify\n #: the request, and their return values are ignored. If an exception\n #: occurred while processing the request, it gets passed to each\n #: teardown_request function. To register a function here, use the\n #: :meth:`teardown_request` decorator.\n #:\n #: .. versionadded:: 0.7\n self.teardown_request_funcs = {}\n\n #: A list of functions that are called when the application context\n #: is destroyed. Since the application context is also torn down\n #: if the request ends this is the place to store code that disconnects\n #: from databases.\n #:\n #: .. versionadded:: 0.9\n self.teardown_appcontext_funcs = []\n\n #: A dictionary with lists of functions that can be used as URL\n #: value processor functions. Whenever a URL is built these functions\n #: are called to modify the dictionary of values in place. The key\n #: `None` here is used for application wide\n #: callbacks, otherwise the key is the name of the blueprint.\n #: Each of these functions has the chance to modify the dictionary\n #:\n #: .. versionadded:: 0.7\n self.url_value_preprocessors = {}\n\n #: A dictionary with lists of functions that can be used as URL value\n #: preprocessors. The key `None` here is used for application wide\n #: callbacks, otherwise the key is the name of the blueprint.\n #: Each of these functions has the chance to modify the dictionary\n #: of URL values before they are used as the keyword arguments of the\n #: view function. For each function registered this one should also\n #: provide a :meth:`url_defaults` function that adds the parameters\n #: automatically again that were removed that way.\n #:\n #: .. versionadded:: 0.7\n self.url_default_functions = {}\n\n #: A dictionary with list of functions that are called without argument\n #: to populate the template context. The key of the dictionary is the\n #: name of the blueprint this function is active for, `None` for all\n #: requests. Each returns a dictionary that the template context is\n #: updated with. To register a function here, use the\n #: :meth:`context_processor` decorator.\n self.template_context_processors = {\n None: [_default_template_ctx_processor]\n }\n\n #: all the attached blueprints in a dictionary by name. Blueprints\n #: can be attached multiple times so this dictionary does not tell\n #: you how often they got attached.\n #:\n #: .. versionadded:: 0.7\n self.blueprints = {}\n\n #: a place where extensions can store application specific state. For\n #: example this is where an extension could store database engines and\n #: similar things. For backwards compatibility extensions should register\n #: themselves like this::\n #:\n #: if not hasattr(app, 'extensions'):\n #: app.extensions = {}\n #: app.extensions['extensionname'] = SomeObject()\n #:\n #: The key must match the name of the `flaskext` module. For example in\n #: case of a \"Flask-Foo\" extension in `flaskext.foo`, the key would be\n #: ``'foo'``.\n #:\n #: .. versionadded:: 0.7\n self.extensions = {}\n\n #: The :class:`~werkzeug.routing.Map` for this instance. You can use\n #: this to change the routing converters after the class was created\n #: but before any routes are connected. Example::\n #:\n #: from werkzeug.routing import BaseConverter\n #:\n #: class ListConverter(BaseConverter):\n #: def to_python(self, value):\n #: return value.split(',')\n #: def to_url(self, values):\n #: return ','.join(BaseConverter.to_url(value)\n #: for value in values)\n #:\n #: app = Flask(__name__)\n #: app.url_map.converters['list'] = ListConverter\n self.url_map = Map()\n\n # tracks internally if the application already handled at least one\n # request.\n self._got_first_request = False\n self._before_request_lock = Lock()\n\n # register the static folder for the application. Do that even\n # if the folder does not exist. First of all it might be created\n # while the server is running (usually happens during development)\n # but also because google appengine stores static files somewhere\n # else when mapped with the .yml file.\n if self.has_static_folder:\n self.add_url_rule(self.static_url_path + '/',\n endpoint='static',\n view_func=self.send_static_file)\n\n def _get_error_handlers(self):\n from warnings import warn\n warn(DeprecationWarning('error_handlers is deprecated, use the '\n 'new error_handler_spec attribute instead.'), stacklevel=1)\n return self._error_handlers\n def _set_error_handlers(self, value):\n self._error_handlers = value\n self.error_handler_spec[None] = value\n error_handlers = property(_get_error_handlers, _set_error_handlers)\n del _get_error_handlers, _set_error_handlers\n\n @locked_cached_property\n def name(self):\n \"\"\"The name of the application. This is usually the import name\n with the difference that it's guessed from the run file if the\n import name is main. This name is used as a display name when\n Flask needs the name of the application. It can be set and overridden\n to change the value.\n\n .. versionadded:: 0.8\n \"\"\"\n if self.import_name == '__main__':\n fn = getattr(sys.modules['__main__'], '__file__', None)\n if fn is None:\n return '__main__'\n return os.path.splitext(os.path.basename(fn))[0]\n return self.import_name\n\n @property\n def propagate_exceptions(self):\n \"\"\"Returns the value of the `PROPAGATE_EXCEPTIONS` configuration\n value in case it's set, otherwise a sensible default is returned.\n\n .. versionadded:: 0.7\n \"\"\"\n rv = self.config['PROPAGATE_EXCEPTIONS']\n if rv is not None:\n return rv\n return self.testing or self.debug\n\n @property\n def preserve_context_on_exception(self):\n \"\"\"Returns the value of the `PRESERVE_CONTEXT_ON_EXCEPTION`\n configuration value in case it's set, otherwise a sensible default\n is returned.\n\n .. versionadded:: 0.7\n \"\"\"\n rv = self.config['PRESERVE_CONTEXT_ON_EXCEPTION']\n if rv is not None:\n return rv\n return self.debug\n\n @property\n def logger(self):\n \"\"\"A :class:`logging.Logger` object for this application. The\n default configuration is to log to stderr if the application is\n in debug mode. This logger can be used to (surprise) log messages.\n Here some examples::\n\n app.logger.debug('A value for debugging')\n app.logger.warning('A warning occurred (%d apples)', 42)\n app.logger.error('An error occurred')\n\n .. versionadded:: 0.3\n \"\"\"\n if self._logger and self._logger.name == self.logger_name:\n return self._logger\n with _logger_lock:\n if self._logger and self._logger.name == self.logger_name:\n return self._logger\n from flask.logging import create_logger\n self._logger = rv = create_logger(self)\n return rv\n\n @locked_cached_property\n def jinja_env(self):\n \"\"\"The Jinja2 environment used to load templates.\"\"\"\n return self.create_jinja_environment()\n\n @property\n def got_first_request(self):\n \"\"\"This attribute is set to `True` if the application started\n handling the first request.\n\n .. versionadded:: 0.8\n \"\"\"\n return self._got_first_request\n\n def make_config(self, instance_relative=False):\n \"\"\"Used to create the config attribute by the Flask constructor.\n The `instance_relative` parameter is passed in from the constructor\n of Flask (there named `instance_relative_config`) and indicates if\n the config should be relative to the instance path or the root path\n of the application.\n\n .. versionadded:: 0.8\n \"\"\"\n root_path = self.root_path\n if instance_relative:\n root_path = self.instance_path\n return Config(root_path, self.default_config)\n\n def auto_find_instance_path(self):\n \"\"\"Tries to locate the instance path if it was not provided to the\n constructor of the application class. It will basically calculate\n the path to a folder named ``instance`` next to your main file or\n the package.\n\n .. versionadded:: 0.8\n \"\"\"\n prefix, package_path = find_package(self.import_name)\n if prefix is None:\n return os.path.join(package_path, 'instance')\n return os.path.join(prefix, 'var', self.name + '-instance')\n\n def open_instance_resource(self, resource, mode='rb'):\n \"\"\"Opens a resource from the application's instance folder\n (:attr:`instance_path`). Otherwise works like\n :meth:`open_resource`. Instance resources can also be opened for\n writing.\n\n :param resource: the name of the resource. To access resources within\n subfolders use forward slashes as separator.\n :param mode: resource file opening mode, default is 'rb'.\n \"\"\"\n return open(os.path.join(self.instance_path, resource), mode)\n\n def create_jinja_environment(self):\n \"\"\"Creates the Jinja2 environment based on :attr:`jinja_options`\n and :meth:`select_jinja_autoescape`. Since 0.7 this also adds\n the Jinja2 globals and filters after initialization. Override\n this function to customize the behavior.\n\n .. versionadded:: 0.5\n \"\"\"\n options = dict(self.jinja_options)\n if 'autoescape' not in options:\n options['autoescape'] = self.select_jinja_autoescape\n rv = Environment(self, **options)\n rv.globals.update(\n url_for=url_for,\n get_flashed_messages=get_flashed_messages,\n config=self.config,\n # request, session and g are normally added with the\n # context processor for efficiency reasons but for imported\n # templates we also want the proxies in there.\n request=request,\n session=session,\n g=g\n )\n rv.filters['tojson'] = json.tojson_filter\n return rv\n\n def create_global_jinja_loader(self):\n \"\"\"Creates the loader for the Jinja2 environment. Can be used to\n override just the loader and keeping the rest unchanged. It's\n discouraged to override this function. Instead one should override\n the :meth:`jinja_loader` function instead.\n\n The global loader dispatches between the loaders of the application\n and the individual blueprints.\n\n .. versionadded:: 0.7\n \"\"\"\n return DispatchingJinjaLoader(self)\n\n def init_jinja_globals(self):\n \"\"\"Deprecated. Used to initialize the Jinja2 globals.\n\n .. versionadded:: 0.5\n .. versionchanged:: 0.7\n This method is deprecated with 0.7. Override\n :meth:`create_jinja_environment` instead.\n \"\"\"\n\n def select_jinja_autoescape(self, filename):\n \"\"\"Returns `True` if autoescaping should be active for the given\n template name.\n\n .. versionadded:: 0.5\n \"\"\"\n if filename is None:\n return False\n return filename.endswith(('.html', '.htm', '.xml', '.xhtml'))\n\n def update_template_context(self, context):\n \"\"\"Update the template context with some commonly used variables.\n This injects request, session, config and g into the template\n context as well as everything template context processors want\n to inject. Note that the as of Flask 0.6, the original values\n in the context will not be overridden if a context processor\n decides to return a value with the same key.\n\n :param context: the context as a dictionary that is updated in place\n to add extra variables.\n \"\"\"\n funcs = self.template_context_processors[None]\n reqctx = _request_ctx_stack.top\n if reqctx is not None:\n bp = reqctx.request.blueprint\n if bp is not None and bp in self.template_context_processors:\n funcs = chain(funcs, self.template_context_processors[bp])\n orig_ctx = context.copy()\n for func in funcs:\n context.update(func())\n # make sure the original values win. This makes it possible to\n # easier add new variables in context processors without breaking\n # existing views.\n context.update(orig_ctx)\n\n def run(self, host=None, port=None, debug=None, **options):\n \"\"\"Runs the application on a local development server. If the\n :attr:`debug` flag is set the server will automatically reload\n for code changes and show a debugger in case an exception happened.\n\n If you want to run the application in debug mode, but disable the\n code execution on the interactive debugger, you can pass\n ``use_evalex=False`` as parameter. This will keep the debugger's\n traceback screen active, but disable code execution.\n\n .. admonition:: Keep in Mind\n\n Flask will suppress any server error with a generic error page\n unless it is in debug mode. As such to enable just the\n interactive debugger without the code reloading, you have to\n invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.\n Setting ``use_debugger`` to `True` without being in debug mode\n won't catch any exceptions because there won't be any to\n catch.\n\n .. versionchanged:: 0.10\n The default port is now picked from the ``SERVER_NAME`` variable.\n\n :param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to\n have the server available externally as well. Defaults to\n ``'127.0.0.1'``.\n :param port: the port of the webserver. Defaults to ``5000`` or the\n port defined in the ``SERVER_NAME`` config variable if\n present.\n :param debug: if given, enable or disable debug mode.\n See :attr:`debug`.\n :param options: the options to be forwarded to the underlying\n Werkzeug server. See\n :func:`werkzeug.serving.run_simple` for more\n information.\n \"\"\"\n from werkzeug.serving import run_simple\n if host is None:\n host = '127.0.0.1'\n if port is None:\n server_name = self.config['SERVER_NAME']\n if server_name and ':' in server_name:\n port = int(server_name.rsplit(':', 1)[1])\n else:\n port = 5000\n if debug is not None:\n self.debug = bool(debug)\n options.setdefault('use_reloader', self.debug)\n options.setdefault('use_debugger', self.debug)\n try:\n run_simple(host, port, self, **options)\n finally:\n # reset the first request information if the development server\n # resetted normally. This makes it possible to restart the server\n # without reloader and that stuff from an interactive shell.\n self._got_first_request = False\n\n def test_client(self, use_cookies=True):\n \"\"\"Creates a test client for this application. For information\n about unit testing head over to :ref:`testing`.\n\n Note that if you are testing for assertions or exceptions in your\n application code, you must set ``app.testing = True`` in order for the\n exceptions to propagate to the test client. Otherwise, the exception\n will be handled by the application (not visible to the test client) and\n the only indication of an AssertionError or other exception will be a\n 500 status code response to the test client. See the :attr:`testing`\n attribute. For example::\n\n app.testing = True\n client = app.test_client()\n\n The test client can be used in a `with` block to defer the closing down\n of the context until the end of the `with` block. This is useful if\n you want to access the context locals for testing::\n\n with app.test_client() as c:\n rv = c.get('/?vodka=42')\n assert request.args['vodka'] == '42'\n\n See :class:`~flask.testing.FlaskClient` for more information.\n\n .. versionchanged:: 0.4\n added support for `with` block usage for the client.\n\n .. versionadded:: 0.7\n The `use_cookies` parameter was added as well as the ability\n to override the client to be used by setting the\n :attr:`test_client_class` attribute.\n \"\"\"\n cls = self.test_client_class\n if cls is None:\n from flask.testing import FlaskClient as cls\n return cls(self, self.response_class, use_cookies=use_cookies)\n\n def open_session(self, request):\n \"\"\"Creates or opens a new session. Default implementation stores all\n session data in a signed cookie. This requires that the\n :attr:`secret_key` is set. Instead of overriding this method\n we recommend replacing the :class:`session_interface`.\n\n :param request: an instance of :attr:`request_class`.\n \"\"\"\n return self.session_interface.open_session(self, request)\n\n def save_session(self, session, response):\n \"\"\"Saves the session if it needs updates. For the default\n implementation, check :meth:`open_session`. Instead of overriding this\n method we recommend replacing the :class:`session_interface`.\n\n :param session: the session to be saved (a\n :class:`~werkzeug.contrib.securecookie.SecureCookie`\n object)\n :param response: an instance of :attr:`response_class`\n \"\"\"\n return self.session_interface.save_session(self, session, response)\n\n def make_null_session(self):\n \"\"\"Creates a new instance of a missing session. Instead of overriding\n this method we recommend replacing the :class:`session_interface`.\n\n .. versionadded:: 0.7\n \"\"\"\n return self.session_interface.make_null_session(self)\n\n def register_module(self, module, **options):\n \"\"\"Registers a module with this application. The keyword argument\n of this function are the same as the ones for the constructor of the\n :class:`Module` class and will override the values of the module if\n provided.\n\n .. versionchanged:: 0.7\n The module system was deprecated in favor for the blueprint\n system.\n \"\"\"\n assert blueprint_is_module(module), 'register_module requires ' \\\n 'actual module objects. Please upgrade to blueprints though.'\n if not self.enable_modules:\n raise RuntimeError('Module support was disabled but code '\n 'attempted to register a module named %r' % module)\n else:\n from warnings import warn\n warn(DeprecationWarning('Modules are deprecated. Upgrade to '\n 'using blueprints. Have a look into the documentation for '\n 'more information. If this module was registered by a '\n 'Flask-Extension upgrade the extension or contact the author '\n 'of that extension instead. (Registered %r)' % module),\n stacklevel=2)\n\n self.register_blueprint(module, **options)\n\n @setupmethod\n def register_blueprint(self, blueprint, **options):\n \"\"\"Registers a blueprint on the application.\n\n .. versionadded:: 0.7\n \"\"\"\n first_registration = False\n if blueprint.name in self.blueprints:\n assert self.blueprints[blueprint.name] is blueprint, \\\n 'A blueprint\\'s name collision occurred between %r and ' \\\n '%r. Both share the same name \"%s\". Blueprints that ' \\\n 'are created on the fly need unique names.' % \\\n (blueprint, self.blueprints[blueprint.name], blueprint.name)\n else:\n self.blueprints[blueprint.name] = blueprint\n first_registration = True\n blueprint.register(self, options, first_registration)\n\n @setupmethod\n def add_url_rule(self, rule, endpoint=None, view_func=None, **options):\n \"\"\"Connects a URL rule. Works exactly like the :meth:`route`\n decorator. If a view_func is provided it will be registered with the\n endpoint.\n\n Basically this example::\n\n @app.route('/')\n def index():\n pass\n\n Is equivalent to the following::\n\n def index():\n pass\n app.add_url_rule('/', 'index', index)\n\n If the view_func is not provided you will need to connect the endpoint\n to a view function like so::\n\n app.view_functions['index'] = index\n\n Internally :meth:`route` invokes :meth:`add_url_rule` so if you want\n to customize the behavior via subclassing you only need to change\n this method.\n\n For more information refer to :ref:`url-route-registrations`.\n\n .. versionchanged:: 0.2\n `view_func` parameter added.\n\n .. versionchanged:: 0.6\n `OPTIONS` is added automatically as method.\n\n :param rule: the URL rule as string\n :param endpoint: the endpoint for the registered URL rule. Flask\n itself assumes the name of the view function as\n endpoint\n :param view_func: the function to call when serving a request to the\n provided endpoint\n :param options: the options to be forwarded to the underlying\n :class:`~werkzeug.routing.Rule` object. A change\n to Werkzeug is handling of method options. methods\n is a list of methods this rule should be limited\n to (`GET`, `POST` etc.). By default a rule\n just listens for `GET` (and implicitly `HEAD`).\n Starting with Flask 0.6, `OPTIONS` is implicitly\n added and handled by the standard request handling.\n \"\"\"\n if endpoint is None:\n endpoint = _endpoint_from_view_func(view_func)\n options['endpoint'] = endpoint\n methods = options.pop('methods', None)\n\n # if the methods are not given and the view_func object knows its\n # methods we can use that instead. If neither exists, we go with\n # a tuple of only `GET` as default.\n if methods is None:\n methods = getattr(view_func, 'methods', None) or ('GET',)\n methods = set(methods)\n\n # Methods that should always be added\n required_methods = set(getattr(view_func, 'required_methods', ()))\n\n # starting with Flask 0.8 the view_func object can disable and\n # force-enable the automatic options handling.\n provide_automatic_options = getattr(view_func,\n 'provide_automatic_options', None)\n\n if provide_automatic_options is None:\n if 'OPTIONS' not in methods:\n provide_automatic_options = True\n required_methods.add('OPTIONS')\n else:\n provide_automatic_options = False\n\n # Add the required methods now.\n methods |= required_methods\n\n # due to a werkzeug bug we need to make sure that the defaults are\n # None if they are an empty dictionary. This should not be necessary\n # with Werkzeug 0.7\n options['defaults'] = options.get('defaults') or None\n\n rule = self.url_rule_class(rule, methods=methods, **options)\n rule.provide_automatic_options = provide_automatic_options\n\n self.url_map.add(rule)\n if view_func is not None:\n old_func = self.view_functions.get(endpoint)\n if old_func is not None and old_func is not view_func:\n raise AssertionError('View function mapping is overwriting an '\n 'existing endpoint function: %s' % endpoint)\n self.view_functions[endpoint] = view_func\n\n def route(self, rule, **options):\n \"\"\"A decorator that is used to register a view function for a\n given URL rule. This does the same thing as :meth:`add_url_rule`\n but is intended for decorator usage::\n\n @app.route('/')\n def index():\n return 'Hello World'\n\n For more information refer to :ref:`url-route-registrations`.\n\n :param rule: the URL rule as string\n :param endpoint: the endpoint for the registered URL rule. Flask\n itself assumes the name of the view function as\n endpoint\n :param options: the options to be forwarded to the underlying\n :class:`~werkzeug.routing.Rule` object. A change\n to Werkzeug is handling of method options. methods\n is a list of methods this rule should be limited\n to (`GET`, `POST` etc.). By default a rule\n just listens for `GET` (and implicitly `HEAD`).\n Starting with Flask 0.6, `OPTIONS` is implicitly\n added and handled by the standard request handling.\n \"\"\"\n def decorator(f):\n endpoint = options.pop('endpoint', None)\n self.add_url_rule(rule, endpoint, f, **options)\n return f\n return decorator\n\n @setupmethod\n def endpoint(self, endpoint):\n \"\"\"A decorator to register a function as an endpoint.\n Example::\n\n @app.endpoint('example.endpoint')\n def example():\n return \"example\"\n\n :param endpoint: the name of the endpoint\n \"\"\"\n def decorator(f):\n self.view_functions[endpoint] = f\n return f\n return decorator\n\n @setupmethod\n def errorhandler(self, code_or_exception):\n \"\"\"A decorator that is used to register a function give a given\n error code. Example::\n\n @app.errorhandler(404)\n def page_not_found(error):\n return 'This page does not exist', 404\n\n You can also register handlers for arbitrary exceptions::\n\n @app.errorhandler(DatabaseError)\n def special_exception_handler(error):\n return 'Database connection failed', 500\n\n You can also register a function as error handler without using\n the :meth:`errorhandler` decorator. The following example is\n equivalent to the one above::\n\n def page_not_found(error):\n return 'This page does not exist', 404\n app.error_handler_spec[None][404] = page_not_found\n\n Setting error handlers via assignments to :attr:`error_handler_spec`\n however is discouraged as it requires fiddling with nested dictionaries\n and the special case for arbitrary exception types.\n\n The first `None` refers to the active blueprint. If the error\n handler should be application wide `None` shall be used.\n\n .. versionadded:: 0.7\n One can now additionally also register custom exception types\n that do not necessarily have to be a subclass of the\n :class:`~werkzeug.exceptions.HTTPException` class.\n\n :param code: the code as integer for the handler\n \"\"\"\n def decorator(f):\n self._register_error_handler(None, code_or_exception, f)\n return f\n return decorator\n\n def register_error_handler(self, code_or_exception, f):\n \"\"\"Alternative error attach function to the :meth:`errorhandler`\n decorator that is more straightforward to use for non decorator\n usage.\n\n .. versionadded:: 0.7\n \"\"\"\n self._register_error_handler(None, code_or_exception, f)\n\n @setupmethod\n def _register_error_handler(self, key, code_or_exception, f):\n if isinstance(code_or_exception, HTTPException):\n code_or_exception = code_or_exception.code\n if isinstance(code_or_exception, integer_types):\n assert code_or_exception != 500 or key is None, \\\n 'It is currently not possible to register a 500 internal ' \\\n 'server error on a per-blueprint level.'\n self.error_handler_spec.setdefault(key, {})[code_or_exception] = f\n else:\n self.error_handler_spec.setdefault(key, {}).setdefault(None, []) \\\n .append((code_or_exception, f))\n\n @setupmethod\n def template_filter(self, name=None):\n \"\"\"A decorator that is used to register custom template filter.\n You can specify a name for the filter, otherwise the function\n name will be used. Example::\n\n @app.template_filter()\n def reverse(s):\n return s[::-1]\n\n :param name: the optional name of the filter, otherwise the\n function name will be used.\n \"\"\"\n def decorator(f):\n self.add_template_filter(f, name=name)\n return f\n return decorator\n\n @setupmethod\n def add_template_filter(self, f, name=None):\n \"\"\"Register a custom template filter. Works exactly like the\n :meth:`template_filter` decorator.\n\n :param name: the optional name of the filter, otherwise the\n function name will be used.\n \"\"\"\n self.jinja_env.filters[name or f.__name__] = f\n\n @setupmethod\n def template_test(self, name=None):\n \"\"\"A decorator that is used to register custom template test.\n You can specify a name for the test, otherwise the function\n name will be used. Example::\n\n @app.template_test()\n def is_prime(n):\n if n == 2:\n return True\n for i in range(2, int(math.ceil(math.sqrt(n))) + 1):\n if n % i == 0:\n return False\n return True\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the test, otherwise the\n function name will be used.\n \"\"\"\n def decorator(f):\n self.add_template_test(f, name=name)\n return f\n return decorator\n\n @setupmethod\n def add_template_test(self, f, name=None):\n \"\"\"Register a custom template test. Works exactly like the\n :meth:`template_test` decorator.\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the test, otherwise the\n function name will be used.\n \"\"\"\n self.jinja_env.tests[name or f.__name__] = f\n\n\n @setupmethod\n def template_global(self, name=None):\n \"\"\"A decorator that is used to register a custom template global function.\n You can specify a name for the global function, otherwise the function\n name will be used. Example::\n\n @app.template_global()\n def double(n):\n return 2 * n\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the global function, otherwise the\n function name will be used.\n \"\"\"\n def decorator(f):\n self.add_template_global(f, name=name)\n return f\n return decorator\n\n @setupmethod\n def add_template_global(self, f, name=None):\n \"\"\"Register a custom template global function. Works exactly like the\n :meth:`template_global` decorator.\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the global function, otherwise the\n function name will be used.\n \"\"\"\n self.jinja_env.globals[name or f.__name__] = f\n\n @setupmethod\n def before_request(self, f):\n \"\"\"Registers a function to run before each request.\"\"\"\n self.before_request_funcs.setdefault(None, []).append(f)\n return f\n\n @setupmethod\n def before_first_request(self, f):\n \"\"\"Registers a function to be run before the first request to this\n instance of the application.\n\n .. versionadded:: 0.8\n \"\"\"\n self.before_first_request_funcs.append(f)\n\n @setupmethod\n def after_request(self, f):\n \"\"\"Register a function to be run after each request. Your function\n must take one parameter, a :attr:`response_class` object and return\n a new response object or the same (see :meth:`process_response`).\n\n As of Flask 0.7 this function might not be executed at the end of the\n request in case an unhandled exception occurred.\n \"\"\"\n self.after_request_funcs.setdefault(None, []).append(f)\n return f\n\n @setupmethod\n def teardown_request(self, f):\n \"\"\"Register a function to be run at the end of each request,\n regardless of whether there was an exception or not. These functions\n are executed when the request context is popped, even if not an\n actual request was performed.\n\n Example::\n\n ctx = app.test_request_context()\n ctx.push()\n ...\n ctx.pop()\n\n When ``ctx.pop()`` is executed in the above example, the teardown\n functions are called just before the request context moves from the\n stack of active contexts. This becomes relevant if you are using\n such constructs in tests.\n\n Generally teardown functions must take every necessary step to avoid\n that they will fail. If they do execute code that might fail they\n will have to surround the execution of these code by try/except\n statements and log occurring errors.\n\n When a teardown function was called because of a exception it will\n be passed an error object.\n\n .. admonition:: Debug Note\n\n In debug mode Flask will not tear down a request on an exception\n immediately. Instead if will keep it alive so that the interactive\n debugger can still access it. This behavior can be controlled\n by the ``PRESERVE_CONTEXT_ON_EXCEPTION`` configuration variable.\n \"\"\"\n self.teardown_request_funcs.setdefault(None, []).append(f)\n return f\n\n @setupmethod\n def teardown_appcontext(self, f):\n \"\"\"Registers a function to be called when the application context\n ends. These functions are typically also called when the request\n context is popped.\n\n Example::\n\n ctx = app.app_context()\n ctx.push()\n ...\n ctx.pop()\n\n When ``ctx.pop()`` is executed in the above example, the teardown\n functions are called just before the app context moves from the\n stack of active contexts. This becomes relevant if you are using\n such constructs in tests.\n\n Since a request context typically also manages an application\n context it would also be called when you pop a request context.\n\n When a teardown function was called because of an exception it will\n be passed an error object.\n\n .. versionadded:: 0.9\n \"\"\"\n self.teardown_appcontext_funcs.append(f)\n return f\n\n @setupmethod\n def context_processor(self, f):\n \"\"\"Registers a template context processor function.\"\"\"\n self.template_context_processors[None].append(f)\n return f\n\n @setupmethod\n def url_value_preprocessor(self, f):\n \"\"\"Registers a function as URL value preprocessor for all view\n functions of the application. It's called before the view functions\n are called and can modify the url values provided.\n \"\"\"\n self.url_value_preprocessors.setdefault(None, []).append(f)\n return f\n\n @setupmethod\n def url_defaults(self, f):\n \"\"\"Callback function for URL defaults for all view functions of the\n application. It's called with the endpoint and values and should\n update the values passed in place.\n \"\"\"\n self.url_default_functions.setdefault(None, []).append(f)\n return f\n\n def handle_http_exception(self, e):\n \"\"\"Handles an HTTP exception. By default this will invoke the\n registered error handlers and fall back to returning the\n exception as response.\n\n .. versionadded:: 0.3\n \"\"\"\n handlers = self.error_handler_spec.get(request.blueprint)\n # Proxy exceptions don't have error codes. We want to always return\n # those unchanged as errors\n if e.code is None:\n return e\n if handlers and e.code in handlers:\n handler = handlers[e.code]\n else:\n handler = self.error_handler_spec[None].get(e.code)\n if handler is None:\n return e\n return handler(e)\n\n def trap_http_exception(self, e):\n \"\"\"Checks if an HTTP exception should be trapped or not. By default\n this will return `False` for all exceptions except for a bad request\n key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to `True`. It\n also returns `True` if ``TRAP_HTTP_EXCEPTIONS`` is set to `True`.\n\n This is called for all HTTP exceptions raised by a view function.\n If it returns `True` for any exception the error handler for this\n exception is not called and it shows up as regular exception in the\n traceback. This is helpful for debugging implicitly raised HTTP\n exceptions.\n\n .. versionadded:: 0.8\n \"\"\"\n if self.config['TRAP_HTTP_EXCEPTIONS']:\n return True\n if self.config['TRAP_BAD_REQUEST_ERRORS']:\n return isinstance(e, BadRequest)\n return False\n\n def handle_user_exception(self, e):\n \"\"\"This method is called whenever an exception occurs that should be\n handled. A special case are\n :class:`~werkzeug.exception.HTTPException`\\s which are forwarded by\n this function to the :meth:`handle_http_exception` method. This\n function will either return a response value or reraise the\n exception with the same traceback.\n\n .. versionadded:: 0.7\n \"\"\"\n exc_type, exc_value, tb = sys.exc_info()\n assert exc_value is e\n\n # ensure not to trash sys.exc_info() at that point in case someone\n # wants the traceback preserved in handle_http_exception. Of course\n # we cannot prevent users from trashing it themselves in a custom\n # trap_http_exception method so that's their fault then.\n if isinstance(e, HTTPException) and not self.trap_http_exception(e):\n return self.handle_http_exception(e)\n\n blueprint_handlers = ()\n handlers = self.error_handler_spec.get(request.blueprint)\n if handlers is not None:\n blueprint_handlers = handlers.get(None, ())\n app_handlers = self.error_handler_spec[None].get(None, ())\n for typecheck, handler in chain(blueprint_handlers, app_handlers):\n if isinstance(e, typecheck):\n return handler(e)\n\n reraise(exc_type, exc_value, tb)\n\n def handle_exception(self, e):\n \"\"\"Default exception handling that kicks in when an exception\n occurs that is not caught. In debug mode the exception will\n be re-raised immediately, otherwise it is logged and the handler\n for a 500 internal server error is used. If no such handler\n exists, a default 500 internal server error message is displayed.\n\n .. versionadded:: 0.3\n \"\"\"\n exc_type, exc_value, tb = sys.exc_info()\n\n got_request_exception.send(self, exception=e)\n handler = self.error_handler_spec[None].get(500)\n\n if self.propagate_exceptions:\n # if we want to repropagate the exception, we can attempt to\n # raise it with the whole traceback in case we can do that\n # (the function was actually called from the except part)\n # otherwise, we just raise the error again\n if exc_value is e:\n reraise(exc_type, exc_value, tb)\n else:\n raise e\n\n self.log_exception((exc_type, exc_value, tb))\n if handler is None:\n return InternalServerError()\n return handler(e)\n\n def log_exception(self, exc_info):\n \"\"\"Logs an exception. This is called by :meth:`handle_exception`\n if debugging is disabled and right before the handler is called.\n The default implementation logs the exception as error on the\n :attr:`logger`.\n\n .. versionadded:: 0.8\n \"\"\"\n self.logger.error('Exception on %s [%s]' % (\n request.path,\n request.method\n ), exc_info=exc_info)\n\n def raise_routing_exception(self, request):\n \"\"\"Exceptions that are recording during routing are reraised with\n this method. During debug we are not reraising redirect requests\n for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising\n a different error instead to help debug situations.\n\n :internal:\n \"\"\"\n if not self.debug \\\n or not isinstance(request.routing_exception, RequestRedirect) \\\n or request.method in ('GET', 'HEAD', 'OPTIONS'):\n raise request.routing_exception\n\n from .debughelpers import FormDataRoutingRedirect\n raise FormDataRoutingRedirect(request)\n\n def dispatch_request(self):\n \"\"\"Does the request dispatching. Matches the URL and returns the\n return value of the view or error handler. This does not have to\n be a response object. In order to convert the return value to a\n proper response object, call :func:`make_response`.\n\n .. versionchanged:: 0.7\n This no longer does the exception handling, this code was\n moved to the new :meth:`full_dispatch_request`.\n \"\"\"\n req = _request_ctx_stack.top.request\n if req.routing_exception is not None:\n self.raise_routing_exception(req)\n rule = req.url_rule\n # if we provide automatic options for this URL and the\n # request came with the OPTIONS method, reply automatically\n if getattr(rule, 'provide_automatic_options', False) \\\n and req.method == 'OPTIONS':\n return self.make_default_options_response()\n # otherwise dispatch to the handler for that endpoint\n return self.view_functions[rule.endpoint](**req.view_args)\n\n def full_dispatch_request(self):\n \"\"\"Dispatches the request and on top of that performs request\n pre and postprocessing as well as HTTP exception catching and\n error handling.\n\n .. versionadded:: 0.7\n \"\"\"\n self.try_trigger_before_first_request_functions()\n try:\n request_started.send(self)\n rv = self.preprocess_request()\n if rv is None:\n rv = self.dispatch_request()\n except Exception as e:\n rv = self.handle_user_exception(e)\n response = self.make_response(rv)\n response = self.process_response(response)\n request_finished.send(self, response=response)\n return response\n\n def try_trigger_before_first_request_functions(self):\n \"\"\"Called before each request and will ensure that it triggers\n the :attr:`before_first_request_funcs` and only exactly once per\n application instance (which means process usually).\n\n :internal:\n \"\"\"\n if self._got_first_request:\n return\n with self._before_request_lock:\n if self._got_first_request:\n return\n self._got_first_request = True\n for func in self.before_first_request_funcs:\n func()\n\n def make_default_options_response(self):\n \"\"\"This method is called to create the default `OPTIONS` response.\n This can be changed through subclassing to change the default\n behavior of `OPTIONS` responses.\n\n .. versionadded:: 0.7\n \"\"\"\n adapter = _request_ctx_stack.top.url_adapter\n if hasattr(adapter, 'allowed_methods'):\n methods = adapter.allowed_methods()\n else:\n # fallback for Werkzeug < 0.7\n methods = []\n try:\n adapter.match(method='--')\n except MethodNotAllowed as e:\n methods = e.valid_methods\n except HTTPException as e:\n pass\n rv = self.response_class()\n rv.allow.update(methods)\n return rv\n\n def should_ignore_error(self, error):\n \"\"\"This is called to figure out if an error should be ignored\n or not as far as the teardown system is concerned. If this\n function returns `True` then the teardown handlers will not be\n passed the error.\n\n .. versionadded:: 0.10\n \"\"\"\n return False\n\n def make_response(self, rv):\n \"\"\"Converts the return value from a view function to a real\n response object that is an instance of :attr:`response_class`.\n\n The following types are allowed for `rv`:\n\n .. tabularcolumns:: |p{3.5cm}|p{9.5cm}|\n\n ======================= ===========================================\n :attr:`response_class` the object is returned unchanged\n :class:`str` a response object is created with the\n string as body\n :class:`unicode` a response object is created with the\n string encoded to utf-8 as body\n a WSGI function the function is called as WSGI application\n and buffered as response object\n :class:`tuple` A tuple in the form ``(response, status,\n headers)`` where `response` is any of the\n types defined here, `status` is a string\n or an integer and `headers` is a list of\n a dictionary with header values.\n ======================= ===========================================\n\n :param rv: the return value from the view function\n\n .. versionchanged:: 0.9\n Previously a tuple was interpreted as the arguments for the\n response object.\n \"\"\"\n status = headers = None\n if isinstance(rv, tuple):\n rv, status, headers = rv + (None,) * (3 - len(rv))\n\n if rv is None:\n raise ValueError('View function did not return a response')\n\n if not isinstance(rv, self.response_class):\n # When we create a response object directly, we let the constructor\n # set the headers and status. We do this because there can be\n # some extra logic involved when creating these objects with\n # specific values (like default content type selection).\n if isinstance(rv, (text_type, bytes, bytearray)):\n rv = self.response_class(rv, headers=headers, status=status)\n headers = status = None\n else:\n rv = self.response_class.force_type(rv, request.environ)\n\n if status is not None:\n if isinstance(status, string_types):\n rv.status = status\n else:\n rv.status_code = status\n if headers:\n rv.headers.extend(headers)\n\n return rv\n\n def create_url_adapter(self, request):\n \"\"\"Creates a URL adapter for the given request. The URL adapter\n is created at a point where the request context is not yet set up\n so the request is passed explicitly.\n\n .. versionadded:: 0.6\n\n .. versionchanged:: 0.9\n This can now also be called without a request object when the\n URL adapter is created for the application context.\n \"\"\"\n if request is not None:\n return self.url_map.bind_to_environ(request.environ,\n server_name=self.config['SERVER_NAME'])\n # We need at the very least the server name to be set for this\n # to work.\n if self.config['SERVER_NAME'] is not None:\n return self.url_map.bind(\n self.config['SERVER_NAME'],\n script_name=self.config['APPLICATION_ROOT'] or '/',\n url_scheme=self.config['PREFERRED_URL_SCHEME'])\n\n def inject_url_defaults(self, endpoint, values):\n \"\"\"Injects the URL defaults for the given endpoint directly into\n the values dictionary passed. This is used internally and\n automatically called on URL building.\n\n .. versionadded:: 0.7\n \"\"\"\n funcs = self.url_default_functions.get(None, ())\n if '.' in endpoint:\n bp = endpoint.rsplit('.', 1)[0]\n funcs = chain(funcs, self.url_default_functions.get(bp, ()))\n for func in funcs:\n func(endpoint, values)\n\n def handle_url_build_error(self, error, endpoint, values):\n \"\"\"Handle :class:`~werkzeug.routing.BuildError` on :meth:`url_for`.\n \"\"\"\n exc_type, exc_value, tb = sys.exc_info()\n for handler in self.url_build_error_handlers:\n try:\n rv = handler(error, endpoint, values)\n if rv is not None:\n return rv\n except BuildError as error:\n pass\n\n # At this point we want to reraise the exception. If the error is\n # still the same one we can reraise it with the original traceback,\n # otherwise we raise it from here.\n if error is exc_value:\n reraise(exc_type, exc_value, tb)\n raise error\n\n def preprocess_request(self):\n \"\"\"Called before the actual request dispatching and will\n call every as :meth:`before_request` decorated function.\n If any of these function returns a value it's handled as\n if it was the return value from the view and further\n request handling is stopped.\n\n This also triggers the :meth:`url_value_processor` functions before\n the actual :meth:`before_request` functions are called.\n \"\"\"\n bp = _request_ctx_stack.top.request.blueprint\n\n funcs = self.url_value_preprocessors.get(None, ())\n if bp is not None and bp in self.url_value_preprocessors:\n funcs = chain(funcs, self.url_value_preprocessors[bp])\n for func in funcs:\n func(request.endpoint, request.view_args)\n\n funcs = self.before_request_funcs.get(None, ())\n if bp is not None and bp in self.before_request_funcs:\n funcs = chain(funcs, self.before_request_funcs[bp])\n for func in funcs:\n rv = func()\n if rv is not None:\n return rv\n\n def process_response(self, response):\n \"\"\"Can be overridden in order to modify the response object\n before it's sent to the WSGI server. By default this will\n call all the :meth:`after_request` decorated functions.\n\n .. versionchanged:: 0.5\n As of Flask 0.5 the functions registered for after request\n execution are called in reverse order of registration.\n\n :param response: a :attr:`response_class` object.\n :return: a new response object or the same, has to be an\n instance of :attr:`response_class`.\n \"\"\"\n ctx = _request_ctx_stack.top\n bp = ctx.request.blueprint\n funcs = ctx._after_request_functions\n if bp is not None and bp in self.after_request_funcs:\n funcs = chain(funcs, reversed(self.after_request_funcs[bp]))\n if None in self.after_request_funcs:\n funcs = chain(funcs, reversed(self.after_request_funcs[None]))\n for handler in funcs:\n response = handler(response)\n if not self.session_interface.is_null_session(ctx.session):\n self.save_session(ctx.session, response)\n return response\n\n def do_teardown_request(self, exc=None):\n \"\"\"Called after the actual request dispatching and will\n call every as :meth:`teardown_request` decorated function. This is\n not actually called by the :class:`Flask` object itself but is always\n triggered when the request context is popped. That way we have a\n tighter control over certain resources under testing environments.\n\n .. versionchanged:: 0.9\n Added the `exc` argument. Previously this was always using the\n current exception information.\n \"\"\"\n if exc is None:\n exc = sys.exc_info()[1]\n funcs = reversed(self.teardown_request_funcs.get(None, ()))\n bp = _request_ctx_stack.top.request.blueprint\n if bp is not None and bp in self.teardown_request_funcs:\n funcs = chain(funcs, reversed(self.teardown_request_funcs[bp]))\n for func in funcs:\n rv = func(exc)\n request_tearing_down.send(self, exc=exc)\n\n def do_teardown_appcontext(self, exc=None):\n \"\"\"Called when an application context is popped. This works pretty\n much the same as :meth:`do_teardown_request` but for the application\n context.\n\n .. versionadded:: 0.9\n \"\"\"\n if exc is None:\n exc = sys.exc_info()[1]\n for func in reversed(self.teardown_appcontext_funcs):\n func(exc)\n appcontext_tearing_down.send(self, exc=exc)\n\n def app_context(self):\n \"\"\"Binds the application only. For as long as the application is bound\n to the current context the :data:`flask.current_app` points to that\n application. An application context is automatically created when a\n request context is pushed if necessary.\n\n Example usage::\n\n with app.app_context():\n ...\n\n .. versionadded:: 0.9\n \"\"\"\n return AppContext(self)\n\n def request_context(self, environ):\n \"\"\"Creates a :class:`~flask.ctx.RequestContext` from the given\n environment and binds it to the current context. This must be used in\n combination with the `with` statement because the request is only bound\n to the current context for the duration of the `with` block.\n\n Example usage::\n\n with app.request_context(environ):\n do_something_with(request)\n\n The object returned can also be used without the `with` statement\n which is useful for working in the shell. The example above is\n doing exactly the same as this code::\n\n ctx = app.request_context(environ)\n ctx.push()\n try:\n do_something_with(request)\n finally:\n ctx.pop()\n\n .. versionchanged:: 0.3\n Added support for non-with statement usage and `with` statement\n is now passed the ctx object.\n\n :param environ: a WSGI environment\n \"\"\"\n return RequestContext(self, environ)\n\n def test_request_context(self, *args, **kwargs):\n \"\"\"Creates a WSGI environment from the given values (see\n :func:`werkzeug.test.EnvironBuilder` for more information, this\n function accepts the same arguments).\n \"\"\"\n from flask.testing import make_test_environ_builder\n builder = make_test_environ_builder(self, *args, **kwargs)\n try:\n return self.request_context(builder.get_environ())\n finally:\n builder.close()\n\n def wsgi_app(self, environ, start_response):\n \"\"\"The actual WSGI application. This is not implemented in\n `__call__` so that middlewares can be applied without losing a\n reference to the class. So instead of doing this::\n\n app = MyMiddleware(app)\n\n It's a better idea to do this instead::\n\n app.wsgi_app = MyMiddleware(app.wsgi_app)\n\n Then you still have the original application object around and\n can continue to call methods on it.\n\n .. versionchanged:: 0.7\n The behavior of the before and after request callbacks was changed\n under error conditions and a new callback was added that will\n always execute at the end of the request, independent on if an\n error occurred or not. See :ref:`callbacks-and-errors`.\n\n :param environ: a WSGI environment\n :param start_response: a callable accepting a status code,\n a list of headers and an optional\n exception context to start the response\n \"\"\"\n ctx = self.request_context(environ)\n ctx.push()\n error = None\n try:\n try:\n response = self.full_dispatch_request()\n except Exception as e:\n error = e\n response = self.make_response(self.handle_exception(e))\n return response(environ, start_response)\n finally:\n if self.should_ignore_error(error):\n error = None\n ctx.auto_pop(error)\n\n @property\n def modules(self):\n from warnings import warn\n warn(DeprecationWarning('Flask.modules is deprecated, use '\n 'Flask.blueprints instead'), stacklevel=2)\n return self.blueprints\n\n def __call__(self, environ, start_response):\n \"\"\"Shortcut for :attr:`wsgi_app`.\"\"\"\n return self.wsgi_app(environ, start_response)\n\n def __repr__(self):\n return '<%s %r>' % (\n self.__class__.__name__,\n self.name,\n )\n" }, { "path": "lib/flask/blueprints.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.blueprints\n ~~~~~~~~~~~~~~~~\n\n Blueprints are the recommended way to implement larger or more\n pluggable applications in Flask 0.7 and later.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nfrom functools import update_wrapper\n\nfrom .helpers import _PackageBoundObject, _endpoint_from_view_func\n\n\nclass BlueprintSetupState(object):\n \"\"\"Temporary holder object for registering a blueprint with the\n application. An instance of this class is created by the\n :meth:`~flask.Blueprint.make_setup_state` method and later passed\n to all register callback functions.\n \"\"\"\n\n def __init__(self, blueprint, app, options, first_registration):\n #: a reference to the current application\n self.app = app\n\n #: a reference to the blueprint that created this setup state.\n self.blueprint = blueprint\n\n #: a dictionary with all options that were passed to the\n #: :meth:`~flask.Flask.register_blueprint` method.\n self.options = options\n\n #: as blueprints can be registered multiple times with the\n #: application and not everything wants to be registered\n #: multiple times on it, this attribute can be used to figure\n #: out if the blueprint was registered in the past already.\n self.first_registration = first_registration\n\n subdomain = self.options.get('subdomain')\n if subdomain is None:\n subdomain = self.blueprint.subdomain\n\n #: The subdomain that the blueprint should be active for, `None`\n #: otherwise.\n self.subdomain = subdomain\n\n url_prefix = self.options.get('url_prefix')\n if url_prefix is None:\n url_prefix = self.blueprint.url_prefix\n\n #: The prefix that should be used for all URLs defined on the\n #: blueprint.\n self.url_prefix = url_prefix\n\n #: A dictionary with URL defaults that is added to each and every\n #: URL that was defined with the blueprint.\n self.url_defaults = dict(self.blueprint.url_values_defaults)\n self.url_defaults.update(self.options.get('url_defaults', ()))\n\n def add_url_rule(self, rule, endpoint=None, view_func=None, **options):\n \"\"\"A helper method to register a rule (and optionally a view function)\n to the application. The endpoint is automatically prefixed with the\n blueprint's name.\n \"\"\"\n if self.url_prefix:\n rule = self.url_prefix + rule\n options.setdefault('subdomain', self.subdomain)\n if endpoint is None:\n endpoint = _endpoint_from_view_func(view_func)\n defaults = self.url_defaults\n if 'defaults' in options:\n defaults = dict(defaults, **options.pop('defaults'))\n self.app.add_url_rule(rule, '%s.%s' % (self.blueprint.name, endpoint),\n view_func, defaults=defaults, **options)\n\n\nclass Blueprint(_PackageBoundObject):\n \"\"\"Represents a blueprint. A blueprint is an object that records\n functions that will be called with the\n :class:`~flask.blueprint.BlueprintSetupState` later to register functions\n or other things on the main application. See :ref:`blueprints` for more\n information.\n\n .. versionadded:: 0.7\n \"\"\"\n\n warn_on_modifications = False\n _got_registered_once = False\n\n def __init__(self, name, import_name, static_folder=None,\n static_url_path=None, template_folder=None,\n url_prefix=None, subdomain=None, url_defaults=None):\n _PackageBoundObject.__init__(self, import_name, template_folder)\n self.name = name\n self.url_prefix = url_prefix\n self.subdomain = subdomain\n self.static_folder = static_folder\n self.static_url_path = static_url_path\n self.deferred_functions = []\n self.view_functions = {}\n if url_defaults is None:\n url_defaults = {}\n self.url_values_defaults = url_defaults\n\n def record(self, func):\n \"\"\"Registers a function that is called when the blueprint is\n registered on the application. This function is called with the\n state as argument as returned by the :meth:`make_setup_state`\n method.\n \"\"\"\n if self._got_registered_once and self.warn_on_modifications:\n from warnings import warn\n warn(Warning('The blueprint was already registered once '\n 'but is getting modified now. These changes '\n 'will not show up.'))\n self.deferred_functions.append(func)\n\n def record_once(self, func):\n \"\"\"Works like :meth:`record` but wraps the function in another\n function that will ensure the function is only called once. If the\n blueprint is registered a second time on the application, the\n function passed is not called.\n \"\"\"\n def wrapper(state):\n if state.first_registration:\n func(state)\n return self.record(update_wrapper(wrapper, func))\n\n def make_setup_state(self, app, options, first_registration=False):\n \"\"\"Creates an instance of :meth:`~flask.blueprints.BlueprintSetupState`\n object that is later passed to the register callback functions.\n Subclasses can override this to return a subclass of the setup state.\n \"\"\"\n return BlueprintSetupState(self, app, options, first_registration)\n\n def register(self, app, options, first_registration=False):\n \"\"\"Called by :meth:`Flask.register_blueprint` to register a blueprint\n on the application. This can be overridden to customize the register\n behavior. Keyword arguments from\n :func:`~flask.Flask.register_blueprint` are directly forwarded to this\n method in the `options` dictionary.\n \"\"\"\n self._got_registered_once = True\n state = self.make_setup_state(app, options, first_registration)\n if self.has_static_folder:\n state.add_url_rule(self.static_url_path + '/',\n view_func=self.send_static_file,\n endpoint='static')\n\n for deferred in self.deferred_functions:\n deferred(state)\n\n def route(self, rule, **options):\n \"\"\"Like :meth:`Flask.route` but for a blueprint. The endpoint for the\n :func:`url_for` function is prefixed with the name of the blueprint.\n \"\"\"\n def decorator(f):\n endpoint = options.pop(\"endpoint\", f.__name__)\n self.add_url_rule(rule, endpoint, f, **options)\n return f\n return decorator\n\n def add_url_rule(self, rule, endpoint=None, view_func=None, **options):\n \"\"\"Like :meth:`Flask.add_url_rule` but for a blueprint. The endpoint for\n the :func:`url_for` function is prefixed with the name of the blueprint.\n \"\"\"\n if endpoint:\n assert '.' not in endpoint, \"Blueprint endpoint's should not contain dot's\"\n self.record(lambda s:\n s.add_url_rule(rule, endpoint, view_func, **options))\n\n def endpoint(self, endpoint):\n \"\"\"Like :meth:`Flask.endpoint` but for a blueprint. This does not\n prefix the endpoint with the blueprint name, this has to be done\n explicitly by the user of this method. If the endpoint is prefixed\n with a `.` it will be registered to the current blueprint, otherwise\n it's an application independent endpoint.\n \"\"\"\n def decorator(f):\n def register_endpoint(state):\n state.app.view_functions[endpoint] = f\n self.record_once(register_endpoint)\n return f\n return decorator\n\n def app_template_filter(self, name=None):\n \"\"\"Register a custom template filter, available application wide. Like\n :meth:`Flask.template_filter` but for a blueprint.\n\n :param name: the optional name of the filter, otherwise the\n function name will be used.\n \"\"\"\n def decorator(f):\n self.add_app_template_filter(f, name=name)\n return f\n return decorator\n\n def add_app_template_filter(self, f, name=None):\n \"\"\"Register a custom template filter, available application wide. Like\n :meth:`Flask.add_template_filter` but for a blueprint. Works exactly\n like the :meth:`app_template_filter` decorator.\n\n :param name: the optional name of the filter, otherwise the\n function name will be used.\n \"\"\"\n def register_template(state):\n state.app.jinja_env.filters[name or f.__name__] = f\n self.record_once(register_template)\n\n def app_template_test(self, name=None):\n \"\"\"Register a custom template test, available application wide. Like\n :meth:`Flask.template_test` but for a blueprint.\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the test, otherwise the\n function name will be used.\n \"\"\"\n def decorator(f):\n self.add_app_template_test(f, name=name)\n return f\n return decorator\n\n def add_app_template_test(self, f, name=None):\n \"\"\"Register a custom template test, available application wide. Like\n :meth:`Flask.add_template_test` but for a blueprint. Works exactly\n like the :meth:`app_template_test` decorator.\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the test, otherwise the\n function name will be used.\n \"\"\"\n def register_template(state):\n state.app.jinja_env.tests[name or f.__name__] = f\n self.record_once(register_template)\n\n def app_template_global(self, name=None):\n \"\"\"Register a custom template global, available application wide. Like\n :meth:`Flask.template_global` but for a blueprint.\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the global, otherwise the\n function name will be used.\n \"\"\"\n def decorator(f):\n self.add_app_template_global(f, name=name)\n return f\n return decorator\n\n def add_app_template_global(self, f, name=None):\n \"\"\"Register a custom template global, available application wide. Like\n :meth:`Flask.add_template_global` but for a blueprint. Works exactly\n like the :meth:`app_template_global` decorator.\n\n .. versionadded:: 0.10\n\n :param name: the optional name of the global, otherwise the\n function name will be used.\n \"\"\"\n def register_template(state):\n state.app.jinja_env.globals[name or f.__name__] = f\n self.record_once(register_template)\n\n def before_request(self, f):\n \"\"\"Like :meth:`Flask.before_request` but for a blueprint. This function\n is only executed before each request that is handled by a function of\n that blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.before_request_funcs\n .setdefault(self.name, []).append(f))\n return f\n\n def before_app_request(self, f):\n \"\"\"Like :meth:`Flask.before_request`. Such a function is executed\n before each request, even if outside of a blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.before_request_funcs\n .setdefault(None, []).append(f))\n return f\n\n def before_app_first_request(self, f):\n \"\"\"Like :meth:`Flask.before_first_request`. Such a function is\n executed before the first request to the application.\n \"\"\"\n self.record_once(lambda s: s.app.before_first_request_funcs.append(f))\n return f\n\n def after_request(self, f):\n \"\"\"Like :meth:`Flask.after_request` but for a blueprint. This function\n is only executed after each request that is handled by a function of\n that blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.after_request_funcs\n .setdefault(self.name, []).append(f))\n return f\n\n def after_app_request(self, f):\n \"\"\"Like :meth:`Flask.after_request` but for a blueprint. Such a function\n is executed after each request, even if outside of the blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.after_request_funcs\n .setdefault(None, []).append(f))\n return f\n\n def teardown_request(self, f):\n \"\"\"Like :meth:`Flask.teardown_request` but for a blueprint. This\n function is only executed when tearing down requests handled by a\n function of that blueprint. Teardown request functions are executed\n when the request context is popped, even when no actual request was\n performed.\n \"\"\"\n self.record_once(lambda s: s.app.teardown_request_funcs\n .setdefault(self.name, []).append(f))\n return f\n\n def teardown_app_request(self, f):\n \"\"\"Like :meth:`Flask.teardown_request` but for a blueprint. Such a\n function is executed when tearing down each request, even if outside of\n the blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.teardown_request_funcs\n .setdefault(None, []).append(f))\n return f\n\n def context_processor(self, f):\n \"\"\"Like :meth:`Flask.context_processor` but for a blueprint. This\n function is only executed for requests handled by a blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.template_context_processors\n .setdefault(self.name, []).append(f))\n return f\n\n def app_context_processor(self, f):\n \"\"\"Like :meth:`Flask.context_processor` but for a blueprint. Such a\n function is executed each request, even if outside of the blueprint.\n \"\"\"\n self.record_once(lambda s: s.app.template_context_processors\n .setdefault(None, []).append(f))\n return f\n\n def app_errorhandler(self, code):\n \"\"\"Like :meth:`Flask.errorhandler` but for a blueprint. This\n handler is used for all requests, even if outside of the blueprint.\n \"\"\"\n def decorator(f):\n self.record_once(lambda s: s.app.errorhandler(code)(f))\n return f\n return decorator\n\n def url_value_preprocessor(self, f):\n \"\"\"Registers a function as URL value preprocessor for this\n blueprint. It's called before the view functions are called and\n can modify the url values provided.\n \"\"\"\n self.record_once(lambda s: s.app.url_value_preprocessors\n .setdefault(self.name, []).append(f))\n return f\n\n def url_defaults(self, f):\n \"\"\"Callback function for URL defaults for this blueprint. It's called\n with the endpoint and values and should update the values passed\n in place.\n \"\"\"\n self.record_once(lambda s: s.app.url_default_functions\n .setdefault(self.name, []).append(f))\n return f\n\n def app_url_value_preprocessor(self, f):\n \"\"\"Same as :meth:`url_value_preprocessor` but application wide.\n \"\"\"\n self.record_once(lambda s: s.app.url_value_preprocessors\n .setdefault(None, []).append(f))\n return f\n\n def app_url_defaults(self, f):\n \"\"\"Same as :meth:`url_defaults` but application wide.\n \"\"\"\n self.record_once(lambda s: s.app.url_default_functions\n .setdefault(None, []).append(f))\n return f\n\n def errorhandler(self, code_or_exception):\n \"\"\"Registers an error handler that becomes active for this blueprint\n only. Please be aware that routing does not happen local to a\n blueprint so an error handler for 404 usually is not handled by\n a blueprint unless it is caused inside a view function. Another\n special case is the 500 internal server error which is always looked\n up from the application.\n\n Otherwise works as the :meth:`~flask.Flask.errorhandler` decorator\n of the :class:`~flask.Flask` object.\n \"\"\"\n def decorator(f):\n self.record_once(lambda s: s.app._register_error_handler(\n self.name, code_or_exception, f))\n return f\n return decorator\n" }, { "path": "lib/flask/config.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.config\n ~~~~~~~~~~~~\n\n Implements the configuration related objects.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\nimport imp\nimport os\nimport errno\n\nfrom werkzeug.utils import import_string\nfrom ._compat import string_types\n\n\nclass ConfigAttribute(object):\n \"\"\"Makes an attribute forward to the config\"\"\"\n\n def __init__(self, name, get_converter=None):\n self.__name__ = name\n self.get_converter = get_converter\n\n def __get__(self, obj, type=None):\n if obj is None:\n return self\n rv = obj.config[self.__name__]\n if self.get_converter is not None:\n rv = self.get_converter(rv)\n return rv\n\n def __set__(self, obj, value):\n obj.config[self.__name__] = value\n\n\nclass Config(dict):\n \"\"\"Works exactly like a dict but provides ways to fill it from files\n or special dictionaries. There are two common patterns to populate the\n config.\n\n Either you can fill the config from a config file::\n\n app.config.from_pyfile('yourconfig.cfg')\n\n Or alternatively you can define the configuration options in the\n module that calls :meth:`from_object` or provide an import path to\n a module that should be loaded. It is also possible to tell it to\n use the same module and with that provide the configuration values\n just before the call::\n\n DEBUG = True\n SECRET_KEY = 'development key'\n app.config.from_object(__name__)\n\n In both cases (loading from any Python file or loading from modules),\n only uppercase keys are added to the config. This makes it possible to use\n lowercase values in the config file for temporary values that are not added\n to the config or to define the config keys in the same file that implements\n the application.\n\n Probably the most interesting way to load configurations is from an\n environment variable pointing to a file::\n\n app.config.from_envvar('YOURAPPLICATION_SETTINGS')\n\n In this case before launching the application you have to set this\n environment variable to the file you want to use. On Linux and OS X\n use the export statement::\n\n export YOURAPPLICATION_SETTINGS='/path/to/config/file'\n\n On windows use `set` instead.\n\n :param root_path: path to which files are read relative from. When the\n config object is created by the application, this is\n the application's :attr:`~flask.Flask.root_path`.\n :param defaults: an optional dictionary of default values\n \"\"\"\n\n def __init__(self, root_path, defaults=None):\n dict.__init__(self, defaults or {})\n self.root_path = root_path\n\n def from_envvar(self, variable_name, silent=False):\n \"\"\"Loads a configuration from an environment variable pointing to\n a configuration file. This is basically just a shortcut with nicer\n error messages for this line of code::\n\n app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])\n\n :param variable_name: name of the environment variable\n :param silent: set to `True` if you want silent failure for missing\n files.\n :return: bool. `True` if able to load config, `False` otherwise.\n \"\"\"\n rv = os.environ.get(variable_name)\n if not rv:\n if silent:\n return False\n raise RuntimeError('The environment variable %r is not set '\n 'and as such configuration could not be '\n 'loaded. Set this variable and make it '\n 'point to a configuration file' %\n variable_name)\n return self.from_pyfile(rv, silent=silent)\n\n def from_pyfile(self, filename, silent=False):\n \"\"\"Updates the values in the config from a Python file. This function\n behaves as if the file was imported as module with the\n :meth:`from_object` function.\n\n :param filename: the filename of the config. This can either be an\n absolute filename or a filename relative to the\n root path.\n :param silent: set to `True` if you want silent failure for missing\n files.\n\n .. versionadded:: 0.7\n `silent` parameter.\n \"\"\"\n filename = os.path.join(self.root_path, filename)\n d = imp.new_module('config')\n d.__file__ = filename\n try:\n with open(filename) as config_file:\n exec(compile(config_file.read(), filename, 'exec'), d.__dict__)\n except IOError as e:\n if silent and e.errno in (errno.ENOENT, errno.EISDIR):\n return False\n e.strerror = 'Unable to load configuration file (%s)' % e.strerror\n raise\n self.from_object(d)\n return True\n\n def from_object(self, obj):\n \"\"\"Updates the values from the given object. An object can be of one\n of the following two types:\n\n - a string: in this case the object with that name will be imported\n - an actual object reference: that object is used directly\n\n Objects are usually either modules or classes.\n\n Just the uppercase variables in that object are stored in the config.\n Example usage::\n\n app.config.from_object('yourapplication.default_config')\n from yourapplication import default_config\n app.config.from_object(default_config)\n\n You should not use this function to load the actual configuration but\n rather configuration defaults. The actual config should be loaded\n with :meth:`from_pyfile` and ideally from a location not within the\n package because the package might be installed system wide.\n\n :param obj: an import name or object\n \"\"\"\n if isinstance(obj, string_types):\n obj = import_string(obj)\n for key in dir(obj):\n if key.isupper():\n self[key] = getattr(obj, key)\n\n def __repr__(self):\n return '<%s %s>' % (self.__class__.__name__, dict.__repr__(self))\n" }, { "path": "lib/flask/ctx.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.ctx\n ~~~~~~~~~\n\n Implements the objects required to keep the context.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\nfrom __future__ import with_statement\n\nimport sys\nfrom functools import update_wrapper\n\nfrom werkzeug.exceptions import HTTPException\n\nfrom .globals import _request_ctx_stack, _app_ctx_stack\nfrom .module import blueprint_is_module\nfrom .signals import appcontext_pushed, appcontext_popped\n\n\nclass _AppCtxGlobals(object):\n \"\"\"A plain object.\"\"\"\n\n def get(self, name, default=None):\n return self.__dict__.get(name, default)\n\n def __contains__(self, item):\n return item in self.__dict__\n\n def __iter__(self):\n return iter(self.__dict__)\n\n def __repr__(self):\n top = _app_ctx_stack.top\n if top is not None:\n return '' % top.app.name\n return object.__repr__(self)\n\n\ndef after_this_request(f):\n \"\"\"Executes a function after this request. This is useful to modify\n response objects. The function is passed the response object and has\n to return the same or a new one.\n\n Example::\n\n @app.route('/')\n def index():\n @after_this_request\n def add_header(response):\n response.headers['X-Foo'] = 'Parachute'\n return response\n return 'Hello World!'\n\n This is more useful if a function other than the view function wants to\n modify a response. For instance think of a decorator that wants to add\n some headers without converting the return value into a response object.\n\n .. versionadded:: 0.9\n \"\"\"\n _request_ctx_stack.top._after_request_functions.append(f)\n return f\n\n\ndef copy_current_request_context(f):\n \"\"\"A helper function that decorates a function to retain the current\n request context. This is useful when working with greenlets. The moment\n the function is decorated a copy of the request context is created and\n then pushed when the function is called.\n\n Example::\n\n import gevent\n from flask import copy_current_request_context\n\n @app.route('/')\n def index():\n @copy_current_request_context\n def do_some_work():\n # do some work here, it can access flask.request like you\n # would otherwise in the view function.\n ...\n gevent.spawn(do_some_work)\n return 'Regular response'\n\n .. versionadded:: 0.10\n \"\"\"\n top = _request_ctx_stack.top\n if top is None:\n raise RuntimeError('This decorator can only be used at local scopes '\n 'when a request context is on the stack. For instance within '\n 'view functions.')\n reqctx = top.copy()\n def wrapper(*args, **kwargs):\n with reqctx:\n return f(*args, **kwargs)\n return update_wrapper(wrapper, f)\n\n\ndef has_request_context():\n \"\"\"If you have code that wants to test if a request context is there or\n not this function can be used. For instance, you may want to take advantage\n of request information if the request object is available, but fail\n silently if it is unavailable.\n\n ::\n\n class User(db.Model):\n\n def __init__(self, username, remote_addr=None):\n self.username = username\n if remote_addr is None and has_request_context():\n remote_addr = request.remote_addr\n self.remote_addr = remote_addr\n\n Alternatively you can also just test any of the context bound objects\n (such as :class:`request` or :class:`g` for truthness)::\n\n class User(db.Model):\n\n def __init__(self, username, remote_addr=None):\n self.username = username\n if remote_addr is None and request:\n remote_addr = request.remote_addr\n self.remote_addr = remote_addr\n\n .. versionadded:: 0.7\n \"\"\"\n return _request_ctx_stack.top is not None\n\n\ndef has_app_context():\n \"\"\"Works like :func:`has_request_context` but for the application\n context. You can also just do a boolean check on the\n :data:`current_app` object instead.\n\n .. versionadded:: 0.9\n \"\"\"\n return _app_ctx_stack.top is not None\n\n\nclass AppContext(object):\n \"\"\"The application context binds an application object implicitly\n to the current thread or greenlet, similar to how the\n :class:`RequestContext` binds request information. The application\n context is also implicitly created if a request context is created\n but the application is not on top of the individual application\n context.\n \"\"\"\n\n def __init__(self, app):\n self.app = app\n self.url_adapter = app.create_url_adapter(None)\n self.g = app.app_ctx_globals_class()\n\n # Like request context, app contexts can be pushed multiple times\n # but there a basic \"refcount\" is enough to track them.\n self._refcnt = 0\n\n def push(self):\n \"\"\"Binds the app context to the current context.\"\"\"\n self._refcnt += 1\n _app_ctx_stack.push(self)\n appcontext_pushed.send(self.app)\n\n def pop(self, exc=None):\n \"\"\"Pops the app context.\"\"\"\n self._refcnt -= 1\n if self._refcnt <= 0:\n if exc is None:\n exc = sys.exc_info()[1]\n self.app.do_teardown_appcontext(exc)\n rv = _app_ctx_stack.pop()\n assert rv is self, 'Popped wrong app context. (%r instead of %r)' \\\n % (rv, self)\n appcontext_popped.send(self.app)\n\n def __enter__(self):\n self.push()\n return self\n\n def __exit__(self, exc_type, exc_value, tb):\n self.pop(exc_value)\n\n\nclass RequestContext(object):\n \"\"\"The request context contains all request relevant information. It is\n created at the beginning of the request and pushed to the\n `_request_ctx_stack` and removed at the end of it. It will create the\n URL adapter and request object for the WSGI environment provided.\n\n Do not attempt to use this class directly, instead use\n :meth:`~flask.Flask.test_request_context` and\n :meth:`~flask.Flask.request_context` to create this object.\n\n When the request context is popped, it will evaluate all the\n functions registered on the application for teardown execution\n (:meth:`~flask.Flask.teardown_request`).\n\n The request context is automatically popped at the end of the request\n for you. In debug mode the request context is kept around if\n exceptions happen so that interactive debuggers have a chance to\n introspect the data. With 0.4 this can also be forced for requests\n that did not fail and outside of `DEBUG` mode. By setting\n ``'flask._preserve_context'`` to `True` on the WSGI environment the\n context will not pop itself at the end of the request. This is used by\n the :meth:`~flask.Flask.test_client` for example to implement the\n deferred cleanup functionality.\n\n You might find this helpful for unittests where you need the\n information from the context local around for a little longer. Make\n sure to properly :meth:`~werkzeug.LocalStack.pop` the stack yourself in\n that situation, otherwise your unittests will leak memory.\n \"\"\"\n\n def __init__(self, app, environ, request=None):\n self.app = app\n if request is None:\n request = app.request_class(environ)\n self.request = request\n self.url_adapter = app.create_url_adapter(self.request)\n self.flashes = None\n self.session = None\n\n # Request contexts can be pushed multiple times and interleaved with\n # other request contexts. Now only if the last level is popped we\n # get rid of them. Additionally if an application context is missing\n # one is created implicitly so for each level we add this information\n self._implicit_app_ctx_stack = []\n\n # indicator if the context was preserved. Next time another context\n # is pushed the preserved context is popped.\n self.preserved = False\n\n # remembers the exception for pop if there is one in case the context\n # preservation kicks in.\n self._preserved_exc = None\n\n # Functions that should be executed after the request on the response\n # object. These will be called before the regular \"after_request\"\n # functions.\n self._after_request_functions = []\n\n self.match_request()\n\n # XXX: Support for deprecated functionality. This is going away with\n # Flask 1.0\n blueprint = self.request.blueprint\n if blueprint is not None:\n # better safe than sorry, we don't want to break code that\n # already worked\n bp = app.blueprints.get(blueprint)\n if bp is not None and blueprint_is_module(bp):\n self.request._is_old_module = True\n\n def _get_g(self):\n return _app_ctx_stack.top.g\n def _set_g(self, value):\n _app_ctx_stack.top.g = value\n g = property(_get_g, _set_g)\n del _get_g, _set_g\n\n def copy(self):\n \"\"\"Creates a copy of this request context with the same request object.\n This can be used to move a request context to a different greenlet.\n Because the actual request object is the same this cannot be used to\n move a request context to a different thread unless access to the\n request object is locked.\n\n .. versionadded:: 0.10\n \"\"\"\n return self.__class__(self.app,\n environ=self.request.environ,\n request=self.request\n )\n\n def match_request(self):\n \"\"\"Can be overridden by a subclass to hook into the matching\n of the request.\n \"\"\"\n try:\n url_rule, self.request.view_args = \\\n self.url_adapter.match(return_rule=True)\n self.request.url_rule = url_rule\n except HTTPException as e:\n self.request.routing_exception = e\n\n def push(self):\n \"\"\"Binds the request context to the current context.\"\"\"\n # If an exception occurs in debug mode or if context preservation is\n # activated under exception situations exactly one context stays\n # on the stack. The rationale is that you want to access that\n # information under debug situations. However if someone forgets to\n # pop that context again we want to make sure that on the next push\n # it's invalidated, otherwise we run at risk that something leaks\n # memory. This is usually only a problem in testsuite since this\n # functionality is not active in production environments.\n top = _request_ctx_stack.top\n if top is not None and top.preserved:\n top.pop(top._preserved_exc)\n\n # Before we push the request context we have to ensure that there\n # is an application context.\n app_ctx = _app_ctx_stack.top\n if app_ctx is None or app_ctx.app != self.app:\n app_ctx = self.app.app_context()\n app_ctx.push()\n self._implicit_app_ctx_stack.append(app_ctx)\n else:\n self._implicit_app_ctx_stack.append(None)\n\n _request_ctx_stack.push(self)\n\n # Open the session at the moment that the request context is\n # available. This allows a custom open_session method to use the\n # request context (e.g. code that access database information\n # stored on `g` instead of the appcontext).\n self.session = self.app.open_session(self.request)\n if self.session is None:\n self.session = self.app.make_null_session()\n\n def pop(self, exc=None):\n \"\"\"Pops the request context and unbinds it by doing that. This will\n also trigger the execution of functions registered by the\n :meth:`~flask.Flask.teardown_request` decorator.\n\n .. versionchanged:: 0.9\n Added the `exc` argument.\n \"\"\"\n app_ctx = self._implicit_app_ctx_stack.pop()\n\n clear_request = False\n if not self._implicit_app_ctx_stack:\n self.preserved = False\n self._preserved_exc = None\n if exc is None:\n exc = sys.exc_info()[1]\n self.app.do_teardown_request(exc)\n\n # If this interpreter supports clearing the exception information\n # we do that now. This will only go into effect on Python 2.x,\n # on 3.x it disappears automatically at the end of the exception\n # stack.\n if hasattr(sys, 'exc_clear'):\n sys.exc_clear()\n\n request_close = getattr(self.request, 'close', None)\n if request_close is not None:\n request_close()\n clear_request = True\n\n rv = _request_ctx_stack.pop()\n assert rv is self, 'Popped wrong request context. (%r instead of %r)' \\\n % (rv, self)\n\n # get rid of circular dependencies at the end of the request\n # so that we don't require the GC to be active.\n if clear_request:\n rv.request.environ['werkzeug.request'] = None\n\n # Get rid of the app as well if necessary.\n if app_ctx is not None:\n app_ctx.pop(exc)\n\n def auto_pop(self, exc):\n if self.request.environ.get('flask._preserve_context') or \\\n (exc is not None and self.app.preserve_context_on_exception):\n self.preserved = True\n self._preserved_exc = exc\n else:\n self.pop(exc)\n\n def __enter__(self):\n self.push()\n return self\n\n def __exit__(self, exc_type, exc_value, tb):\n # do not pop the request stack if we are in debug mode and an\n # exception happened. This will allow the debugger to still\n # access the request object in the interactive shell. Furthermore\n # the context can be force kept alive for the test client.\n # See flask.testing for how this works.\n self.auto_pop(exc_value)\n\n def __repr__(self):\n return '<%s \\'%s\\' [%s] of %s>' % (\n self.__class__.__name__,\n self.request.url,\n self.request.method,\n self.app.name,\n )\n" }, { "path": "lib/flask/debughelpers.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.debughelpers\n ~~~~~~~~~~~~~~~~~~\n\n Various helpers to make the development experience better.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nfrom ._compat import implements_to_string\n\n\nclass UnexpectedUnicodeError(AssertionError, UnicodeError):\n \"\"\"Raised in places where we want some better error reporting for\n unexpected unicode or binary data.\n \"\"\"\n\n\n@implements_to_string\nclass DebugFilesKeyError(KeyError, AssertionError):\n \"\"\"Raised from request.files during debugging. The idea is that it can\n provide a better error message than just a generic KeyError/BadRequest.\n \"\"\"\n\n def __init__(self, request, key):\n form_matches = request.form.getlist(key)\n buf = ['You tried to access the file \"%s\" in the request.files '\n 'dictionary but it does not exist. The mimetype for the request '\n 'is \"%s\" instead of \"multipart/form-data\" which means that no '\n 'file contents were transmitted. To fix this error you should '\n 'provide enctype=\"multipart/form-data\" in your form.' %\n (key, request.mimetype)]\n if form_matches:\n buf.append('\\n\\nThe browser instead transmitted some file names. '\n 'This was submitted: %s' % ', '.join('\"%s\"' % x\n for x in form_matches))\n self.msg = ''.join(buf)\n\n def __str__(self):\n return self.msg\n\n\nclass FormDataRoutingRedirect(AssertionError):\n \"\"\"This exception is raised by Flask in debug mode if it detects a\n redirect caused by the routing system when the request method is not\n GET, HEAD or OPTIONS. Reasoning: form data will be dropped.\n \"\"\"\n\n def __init__(self, request):\n exc = request.routing_exception\n buf = ['A request was sent to this URL (%s) but a redirect was '\n 'issued automatically by the routing system to \"%s\".'\n % (request.url, exc.new_url)]\n\n # In case just a slash was appended we can be extra helpful\n if request.base_url + '/' == exc.new_url.split('?')[0]:\n buf.append(' The URL was defined with a trailing slash so '\n 'Flask will automatically redirect to the URL '\n 'with the trailing slash if it was accessed '\n 'without one.')\n\n buf.append(' Make sure to directly send your %s-request to this URL '\n 'since we can\\'t make browsers or HTTP clients redirect '\n 'with form data reliably or without user interaction.' %\n request.method)\n buf.append('\\n\\nNote: this exception is only raised in debug mode')\n AssertionError.__init__(self, ''.join(buf).encode('utf-8'))\n\n\ndef attach_enctype_error_multidict(request):\n \"\"\"Since Flask 0.8 we're monkeypatching the files object in case a\n request is detected that does not use multipart form data but the files\n object is accessed.\n \"\"\"\n oldcls = request.files.__class__\n class newcls(oldcls):\n def __getitem__(self, key):\n try:\n return oldcls.__getitem__(self, key)\n except KeyError as e:\n if key not in request.form:\n raise\n raise DebugFilesKeyError(request, key)\n newcls.__name__ = oldcls.__name__\n newcls.__module__ = oldcls.__module__\n request.files.__class__ = newcls\n" }, { "path": "lib/flask/ext/__init__.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.ext\n ~~~~~~~~~\n\n Redirect imports for extensions. This module basically makes it possible\n for us to transition from flaskext.foo to flask_foo without having to\n force all extensions to upgrade at the same time.\n\n When a user does ``from flask.ext.foo import bar`` it will attempt to\n import ``from flask_foo import bar`` first and when that fails it will\n try to import ``from flaskext.foo import bar``.\n\n We're switching from namespace packages because it was just too painful for\n everybody involved.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\n\ndef setup():\n from ..exthook import ExtensionImporter\n importer = ExtensionImporter(['flask_%s', 'flaskext.%s'], __name__)\n importer.install()\n\n\nsetup()\ndel setup\n" }, { "path": "lib/flask/exthook.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.exthook\n ~~~~~~~~~~~~~\n\n Redirect imports for extensions. This module basically makes it possible\n for us to transition from flaskext.foo to flask_foo without having to\n force all extensions to upgrade at the same time.\n\n When a user does ``from flask.ext.foo import bar`` it will attempt to\n import ``from flask_foo import bar`` first and when that fails it will\n try to import ``from flaskext.foo import bar``.\n\n We're switching from namespace packages because it was just too painful for\n everybody involved.\n\n This is used by `flask.ext`.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nimport sys\nimport os\nfrom ._compat import reraise\n\n\nclass ExtensionImporter(object):\n \"\"\"This importer redirects imports from this submodule to other locations.\n This makes it possible to transition from the old flaskext.name to the\n newer flask_name without people having a hard time.\n \"\"\"\n\n def __init__(self, module_choices, wrapper_module):\n self.module_choices = module_choices\n self.wrapper_module = wrapper_module\n self.prefix = wrapper_module + '.'\n self.prefix_cutoff = wrapper_module.count('.') + 1\n\n def __eq__(self, other):\n return self.__class__.__module__ == other.__class__.__module__ and \\\n self.__class__.__name__ == other.__class__.__name__ and \\\n self.wrapper_module == other.wrapper_module and \\\n self.module_choices == other.module_choices\n\n def __ne__(self, other):\n return not self.__eq__(other)\n\n def install(self):\n sys.meta_path[:] = [x for x in sys.meta_path if self != x] + [self]\n\n def find_module(self, fullname, path=None):\n if fullname.startswith(self.prefix):\n return self\n\n def load_module(self, fullname):\n if fullname in sys.modules:\n return sys.modules[fullname]\n modname = fullname.split('.', self.prefix_cutoff)[self.prefix_cutoff]\n for path in self.module_choices:\n realname = path % modname\n try:\n __import__(realname)\n except ImportError:\n exc_type, exc_value, tb = sys.exc_info()\n # since we only establish the entry in sys.modules at the\n # very this seems to be redundant, but if recursive imports\n # happen we will call into the move import a second time.\n # On the second invocation we still don't have an entry for\n # fullname in sys.modules, but we will end up with the same\n # fake module name and that import will succeed since this\n # one already has a temporary entry in the modules dict.\n # Since this one \"succeeded\" temporarily that second\n # invocation now will have created a fullname entry in\n # sys.modules which we have to kill.\n sys.modules.pop(fullname, None)\n\n # If it's an important traceback we reraise it, otherwise\n # we swallow it and try the next choice. The skipped frame\n # is the one from __import__ above which we don't care about\n if self.is_important_traceback(realname, tb):\n reraise(exc_type, exc_value, tb.tb_next)\n continue\n module = sys.modules[fullname] = sys.modules[realname]\n if '.' not in modname:\n setattr(sys.modules[self.wrapper_module], modname, module)\n return module\n raise ImportError('No module named %s' % fullname)\n\n def is_important_traceback(self, important_module, tb):\n \"\"\"Walks a traceback's frames and checks if any of the frames\n originated in the given important module. If that is the case then we\n were able to import the module itself but apparently something went\n wrong when the module was imported. (Eg: import of an import failed).\n \"\"\"\n while tb is not None:\n if self.is_important_frame(important_module, tb):\n return True\n tb = tb.tb_next\n return False\n\n def is_important_frame(self, important_module, tb):\n \"\"\"Checks a single frame if it's important.\"\"\"\n g = tb.tb_frame.f_globals\n if '__name__' not in g:\n return False\n\n module_name = g['__name__']\n\n # Python 2.7 Behavior. Modules are cleaned up late so the\n # name shows up properly here. Success!\n if module_name == important_module:\n return True\n\n # Some python versions will will clean up modules so early that the\n # module name at that point is no longer set. Try guessing from\n # the filename then.\n filename = os.path.abspath(tb.tb_frame.f_code.co_filename)\n test_string = os.path.sep + important_module.replace('.', os.path.sep)\n return test_string + '.py' in filename or \\\n test_string + os.path.sep + '__init__.py' in filename\n" }, { "path": "lib/flask/globals.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.globals\n ~~~~~~~~~~~~~\n\n Defines all the global objects that are proxies to the current\n active context.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\nfrom functools import partial\nfrom werkzeug.local import LocalStack, LocalProxy\n\n\ndef _lookup_req_object(name):\n top = _request_ctx_stack.top\n if top is None:\n raise RuntimeError('working outside of request context')\n return getattr(top, name)\n\n\ndef _lookup_app_object(name):\n top = _app_ctx_stack.top\n if top is None:\n raise RuntimeError('working outside of application context')\n return getattr(top, name)\n\n\ndef _find_app():\n top = _app_ctx_stack.top\n if top is None:\n raise RuntimeError('working outside of application context')\n return top.app\n\n\n# context locals\n_request_ctx_stack = LocalStack()\n_app_ctx_stack = LocalStack()\ncurrent_app = LocalProxy(_find_app)\nrequest = LocalProxy(partial(_lookup_req_object, 'request'))\nsession = LocalProxy(partial(_lookup_req_object, 'session'))\ng = LocalProxy(partial(_lookup_app_object, 'g'))\n" }, { "path": "lib/flask/helpers.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.helpers\n ~~~~~~~~~~~~~\n\n Implements various helpers.\n\n :copyright: (c) 2011 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\n\nimport os\nimport sys\nimport pkgutil\nimport posixpath\nimport mimetypes\nfrom time import time\nfrom zlib import adler32\nfrom threading import RLock\nfrom werkzeug.routing import BuildError\nfrom functools import update_wrapper\n\ntry:\n from werkzeug.urls import url_quote\nexcept ImportError:\n from urlparse import quote as url_quote\n\nfrom werkzeug.datastructures import Headers\nfrom werkzeug.exceptions import NotFound\n\n# this was moved in 0.7\ntry:\n from werkzeug.wsgi import wrap_file\nexcept ImportError:\n from werkzeug.utils import wrap_file\n\nfrom jinja2 import FileSystemLoader\n\nfrom .signals import message_flashed\nfrom .globals import session, _request_ctx_stack, _app_ctx_stack, \\\n current_app, request\nfrom ._compat import string_types, text_type\n\n\n# sentinel\n_missing = object()\n\n\n# what separators does this operating system provide that are not a slash?\n# this is used by the send_from_directory function to ensure that nobody is\n# able to access files from outside the filesystem.\n_os_alt_seps = list(sep for sep in [os.path.sep, os.path.altsep]\n if sep not in (None, '/'))\n\n\ndef _endpoint_from_view_func(view_func):\n \"\"\"Internal helper that returns the default endpoint for a given\n function. This always is the function name.\n \"\"\"\n assert view_func is not None, 'expected view func if endpoint ' \\\n 'is not provided.'\n return view_func.__name__\n\n\ndef stream_with_context(generator_or_function):\n \"\"\"Request contexts disappear when the response is started on the server.\n This is done for efficiency reasons and to make it less likely to encounter\n memory leaks with badly written WSGI middlewares. The downside is that if\n you are using streamed responses, the generator cannot access request bound\n information any more.\n\n This function however can help you keep the context around for longer::\n\n from flask import stream_with_context, request, Response\n\n @app.route('/stream')\n def streamed_response():\n @stream_with_context\n def generate():\n yield 'Hello '\n yield request.args['name']\n yield '!'\n return Response(generate())\n\n Alternatively it can also be used around a specific generator::\n\n from flask import stream_with_context, request, Response\n\n @app.route('/stream')\n def streamed_response():\n def generate():\n yield 'Hello '\n yield request.args['name']\n yield '!'\n return Response(stream_with_context(generate()))\n\n .. versionadded:: 0.9\n \"\"\"\n try:\n gen = iter(generator_or_function)\n except TypeError:\n def decorator(*args, **kwargs):\n gen = generator_or_function()\n return stream_with_context(gen)\n return update_wrapper(decorator, generator_or_function)\n\n def generator():\n ctx = _request_ctx_stack.top\n if ctx is None:\n raise RuntimeError('Attempted to stream with context but '\n 'there was no context in the first place to keep around.')\n with ctx:\n # Dummy sentinel. Has to be inside the context block or we're\n # not actually keeping the context around.\n yield None\n\n # The try/finally is here so that if someone passes a WSGI level\n # iterator in we're still running the cleanup logic. Generators\n # don't need that because they are closed on their destruction\n # automatically.\n try:\n for item in gen:\n yield item\n finally:\n if hasattr(gen, 'close'):\n gen.close()\n\n # The trick is to start the generator. Then the code execution runs until\n # the first dummy None is yielded at which point the context was already\n # pushed. This item is discarded. Then when the iteration continues the\n # real generator is executed.\n wrapped_g = generator()\n next(wrapped_g)\n return wrapped_g\n\n\ndef make_response(*args):\n \"\"\"Sometimes it is necessary to set additional headers in a view. Because\n views do not have to return response objects but can return a value that\n is converted into a response object by Flask itself, it becomes tricky to\n add headers to it. This function can be called instead of using a return\n and you will get a response object which you can use to attach headers.\n\n If view looked like this and you want to add a new header::\n\n def index():\n return render_template('index.html', foo=42)\n\n You can now do something like this::\n\n def index():\n response = make_response(render_template('index.html', foo=42))\n response.headers['X-Parachutes'] = 'parachutes are cool'\n return response\n\n This function accepts the very same arguments you can return from a\n view function. This for example creates a response with a 404 error\n code::\n\n response = make_response(render_template('not_found.html'), 404)\n\n The other use case of this function is to force the return value of a\n view function into a response which is helpful with view\n decorators::\n\n response = make_response(view_function())\n response.headers['X-Parachutes'] = 'parachutes are cool'\n\n Internally this function does the following things:\n\n - if no arguments are passed, it creates a new response argument\n - if one argument is passed, :meth:`flask.Flask.make_response`\n is invoked with it.\n - if more than one argument is passed, the arguments are passed\n to the :meth:`flask.Flask.make_response` function as tuple.\n\n .. versionadded:: 0.6\n \"\"\"\n if not args:\n return current_app.response_class()\n if len(args) == 1:\n args = args[0]\n return current_app.make_response(args)\n\n\ndef url_for(endpoint, **values):\n \"\"\"Generates a URL to the given endpoint with the method provided.\n\n Variable arguments that are unknown to the target endpoint are appended\n to the generated URL as query arguments. If the value of a query argument\n is `None`, the whole pair is skipped. In case blueprints are active\n you can shortcut references to the same blueprint by prefixing the\n local endpoint with a dot (``.``).\n\n This will reference the index function local to the current blueprint::\n\n url_for('.index')\n\n For more information, head over to the :ref:`Quickstart `.\n\n To integrate applications, :class:`Flask` has a hook to intercept URL build\n errors through :attr:`Flask.build_error_handler`. The `url_for` function\n results in a :exc:`~werkzeug.routing.BuildError` when the current app does\n not have a URL for the given endpoint and values. When it does, the\n :data:`~flask.current_app` calls its :attr:`~Flask.build_error_handler` if\n it is not `None`, which can return a string to use as the result of\n `url_for` (instead of `url_for`'s default to raise the\n :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception.\n An example::\n\n def external_url_handler(error, endpoint, **values):\n \"Looks up an external URL when `url_for` cannot build a URL.\"\n # This is an example of hooking the build_error_handler.\n # Here, lookup_url is some utility function you've built\n # which looks up the endpoint in some external URL registry.\n url = lookup_url(endpoint, **values)\n if url is None:\n # External lookup did not have a URL.\n # Re-raise the BuildError, in context of original traceback.\n exc_type, exc_value, tb = sys.exc_info()\n if exc_value is error:\n raise exc_type, exc_value, tb\n else:\n raise error\n # url_for will use this result, instead of raising BuildError.\n return url\n\n app.build_error_handler = external_url_handler\n\n Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and\n `endpoint` and `**values` are the arguments passed into `url_for`. Note\n that this is for building URLs outside the current application, and not for\n handling 404 NotFound errors.\n\n .. versionadded:: 0.10\n The `_scheme` parameter was added.\n\n .. versionadded:: 0.9\n The `_anchor` and `_method` parameters were added.\n\n .. versionadded:: 0.9\n Calls :meth:`Flask.handle_build_error` on\n :exc:`~werkzeug.routing.BuildError`.\n\n :param endpoint: the endpoint of the URL (name of the function)\n :param values: the variable arguments of the URL rule\n :param _external: if set to `True`, an absolute URL is generated. Server\n address can be changed via `SERVER_NAME` configuration variable which\n defaults to `localhost`.\n :param _scheme: a string specifying the desired URL scheme. The `_external`\n parameter must be set to `True` or a `ValueError` is raised.\n :param _anchor: if provided this is added as anchor to the URL.\n :param _method: if provided this explicitly specifies an HTTP method.\n \"\"\"\n appctx = _app_ctx_stack.top\n reqctx = _request_ctx_stack.top\n if appctx is None:\n raise RuntimeError('Attempted to generate a URL without the '\n 'application context being pushed. This has to be '\n 'executed when application context is available.')\n\n # If request specific information is available we have some extra\n # features that support \"relative\" urls.\n if reqctx is not None:\n url_adapter = reqctx.url_adapter\n blueprint_name = request.blueprint\n if not reqctx.request._is_old_module:\n if endpoint[:1] == '.':\n if blueprint_name is not None:\n endpoint = blueprint_name + endpoint\n else:\n endpoint = endpoint[1:]\n else:\n # TODO: get rid of this deprecated functionality in 1.0\n if '.' not in endpoint:\n if blueprint_name is not None:\n endpoint = blueprint_name + '.' + endpoint\n elif endpoint.startswith('.'):\n endpoint = endpoint[1:]\n external = values.pop('_external', False)\n\n # Otherwise go with the url adapter from the appctx and make\n # the urls external by default.\n else:\n url_adapter = appctx.url_adapter\n if url_adapter is None:\n raise RuntimeError('Application was not able to create a URL '\n 'adapter for request independent URL generation. '\n 'You might be able to fix this by setting '\n 'the SERVER_NAME config variable.')\n external = values.pop('_external', True)\n\n anchor = values.pop('_anchor', None)\n method = values.pop('_method', None)\n scheme = values.pop('_scheme', None)\n appctx.app.inject_url_defaults(endpoint, values)\n\n if scheme is not None:\n if not external:\n raise ValueError('When specifying _scheme, _external must be True')\n url_adapter.url_scheme = scheme\n\n try:\n rv = url_adapter.build(endpoint, values, method=method,\n force_external=external)\n except BuildError as error:\n # We need to inject the values again so that the app callback can\n # deal with that sort of stuff.\n values['_external'] = external\n values['_anchor'] = anchor\n values['_method'] = method\n return appctx.app.handle_url_build_error(error, endpoint, values)\n\n if anchor is not None:\n rv += '#' + url_quote(anchor)\n return rv\n\n\ndef get_template_attribute(template_name, attribute):\n \"\"\"Loads a macro (or variable) a template exports. This can be used to\n invoke a macro from within Python code. If you for example have a\n template named `_cider.html` with the following contents:\n\n .. sourcecode:: html+jinja\n\n {% macro hello(name) %}Hello {{ name }}!{% endmacro %}\n\n You can access this from Python code like this::\n\n hello = get_template_attribute('_cider.html', 'hello')\n return hello('World')\n\n .. versionadded:: 0.2\n\n :param template_name: the name of the template\n :param attribute: the name of the variable of macro to access\n \"\"\"\n return getattr(current_app.jinja_env.get_template(template_name).module,\n attribute)\n\n\ndef flash(message, category='message'):\n \"\"\"Flashes a message to the next request. In order to remove the\n flashed message from the session and to display it to the user,\n the template has to call :func:`get_flashed_messages`.\n\n .. versionchanged:: 0.3\n `category` parameter added.\n\n :param message: the message to be flashed.\n :param category: the category for the message. The following values\n are recommended: ``'message'`` for any kind of message,\n ``'error'`` for errors, ``'info'`` for information\n messages and ``'warning'`` for warnings. However any\n kind of string can be used as category.\n \"\"\"\n # Original implementation:\n #\n # session.setdefault('_flashes', []).append((category, message))\n #\n # This assumed that changes made to mutable structures in the session are\n # are always in sync with the sess on object, which is not true for session\n # implementations that use external storage for keeping their keys/values.\n flashes = session.get('_flashes', [])\n flashes.append((category, message))\n session['_flashes'] = flashes\n message_flashed.send(current_app._get_current_object(),\n message=message, category=category)\n\n\ndef get_flashed_messages(with_categories=False, category_filter=[]):\n \"\"\"Pulls all flashed messages from the session and returns them.\n Further calls in the same request to the function will return\n the same messages. By default just the messages are returned,\n but when `with_categories` is set to `True`, the return value will\n be a list of tuples in the form ``(category, message)`` instead.\n\n Filter the flashed messages to one or more categories by providing those\n categories in `category_filter`. This allows rendering categories in\n separate html blocks. The `with_categories` and `category_filter`\n arguments are distinct:\n\n * `with_categories` controls whether categories are returned with message\n text (`True` gives a tuple, where `False` gives just the message text).\n * `category_filter` filters the messages down to only those matching the\n provided categories.\n\n See :ref:`message-flashing-pattern` for examples.\n\n .. versionchanged:: 0.3\n `with_categories` parameter added.\n\n .. versionchanged:: 0.9\n `category_filter` parameter added.\n\n :param with_categories: set to `True` to also receive categories.\n :param category_filter: whitelist of categories to limit return values\n \"\"\"\n flashes = _request_ctx_stack.top.flashes\n if flashes is None:\n _request_ctx_stack.top.flashes = flashes = session.pop('_flashes') \\\n if '_flashes' in session else []\n if category_filter:\n flashes = list(filter(lambda f: f[0] in category_filter, flashes))\n if not with_categories:\n return [x[1] for x in flashes]\n return flashes\n\n\ndef send_file(filename_or_fp, mimetype=None, as_attachment=False,\n attachment_filename=None, add_etags=True,\n cache_timeout=None, conditional=False):\n \"\"\"Sends the contents of a file to the client. This will use the\n most efficient method available and configured. By default it will\n try to use the WSGI server's file_wrapper support. Alternatively\n you can set the application's :attr:`~Flask.use_x_sendfile` attribute\n to ``True`` to directly emit an `X-Sendfile` header. This however\n requires support of the underlying webserver for `X-Sendfile`.\n\n By default it will try to guess the mimetype for you, but you can\n also explicitly provide one. For extra security you probably want\n to send certain files as attachment (HTML for instance). The mimetype\n guessing requires a `filename` or an `attachment_filename` to be\n provided.\n\n Please never pass filenames to this function from user sources without\n checking them first. Something like this is usually sufficient to\n avoid security problems::\n\n if '..' in filename or filename.startswith('/'):\n abort(404)\n\n .. versionadded:: 0.2\n\n .. versionadded:: 0.5\n The `add_etags`, `cache_timeout` and `conditional` parameters were\n added. The default behavior is now to attach etags.\n\n .. versionchanged:: 0.7\n mimetype guessing and etag support for file objects was\n deprecated because it was unreliable. Pass a filename if you are\n able to, otherwise attach an etag yourself. This functionality\n will be removed in Flask 1.0\n\n .. versionchanged:: 0.9\n cache_timeout pulls its default from application config, when None.\n\n :param filename_or_fp: the filename of the file to send. This is\n relative to the :attr:`~Flask.root_path` if a\n relative path is specified.\n Alternatively a file object might be provided\n in which case `X-Sendfile` might not work and\n fall back to the traditional method. Make sure\n that the file pointer is positioned at the start\n of data to send before calling :func:`send_file`.\n :param mimetype: the mimetype of the file if provided, otherwise\n auto detection happens.\n :param as_attachment: set to `True` if you want to send this file with\n a ``Content-Disposition: attachment`` header.\n :param attachment_filename: the filename for the attachment if it\n differs from the file's filename.\n :param add_etags: set to `False` to disable attaching of etags.\n :param conditional: set to `True` to enable conditional responses.\n\n :param cache_timeout: the timeout in seconds for the headers. When `None`\n (default), this value is set by\n :meth:`~Flask.get_send_file_max_age` of\n :data:`~flask.current_app`.\n \"\"\"\n mtime = None\n if isinstance(filename_or_fp, string_types):\n filename = filename_or_fp\n file = None\n else:\n from warnings import warn\n file = filename_or_fp\n filename = getattr(file, 'name', None)\n\n # XXX: this behavior is now deprecated because it was unreliable.\n # removed in Flask 1.0\n if not attachment_filename and not mimetype \\\n and isinstance(filename, string_types):\n warn(DeprecationWarning('The filename support for file objects '\n 'passed to send_file is now deprecated. Pass an '\n 'attach_filename if you want mimetypes to be guessed.'),\n stacklevel=2)\n if add_etags:\n warn(DeprecationWarning('In future flask releases etags will no '\n 'longer be generated for file objects passed to the send_file '\n 'function because this behavior was unreliable. Pass '\n 'filenames instead if possible, otherwise attach an etag '\n 'yourself based on another value'), stacklevel=2)\n\n if filename is not None:\n if not os.path.isabs(filename):\n filename = os.path.join(current_app.root_path, filename)\n if mimetype is None and (filename or attachment_filename):\n mimetype = mimetypes.guess_type(filename or attachment_filename)[0]\n if mimetype is None:\n mimetype = 'application/octet-stream'\n\n headers = Headers()\n if as_attachment:\n if attachment_filename is None:\n if filename is None:\n raise TypeError('filename unavailable, required for '\n 'sending as attachment')\n attachment_filename = os.path.basename(filename)\n headers.add('Content-Disposition', 'attachment',\n filename=attachment_filename)\n\n if current_app.use_x_sendfile and filename:\n if file is not None:\n file.close()\n headers['X-Sendfile'] = filename\n headers['Content-Length'] = os.path.getsize(filename)\n data = None\n else:\n if file is None:\n file = open(filename, 'rb')\n mtime = os.path.getmtime(filename)\n headers['Content-Length'] = os.path.getsize(filename)\n data = wrap_file(request.environ, file)\n\n rv = current_app.response_class(data, mimetype=mimetype, headers=headers,\n direct_passthrough=True)\n\n # if we know the file modification date, we can store it as the\n # the time of the last modification.\n if mtime is not None:\n rv.last_modified = int(mtime)\n\n rv.cache_control.public = True\n if cache_timeout is None:\n cache_timeout = current_app.get_send_file_max_age(filename)\n if cache_timeout is not None:\n rv.cache_control.max_age = cache_timeout\n rv.expires = int(time() + cache_timeout)\n\n if add_etags and filename is not None:\n rv.set_etag('flask-%s-%s-%s' % (\n os.path.getmtime(filename),\n os.path.getsize(filename),\n adler32(\n filename.encode('utf-8') if isinstance(filename, text_type)\n else filename\n ) & 0xffffffff\n ))\n if conditional:\n rv = rv.make_conditional(request)\n # make sure we don't send x-sendfile for servers that\n # ignore the 304 status code for x-sendfile.\n if rv.status_code == 304:\n rv.headers.pop('x-sendfile', None)\n return rv\n\n\ndef safe_join(directory, filename):\n \"\"\"Safely join `directory` and `filename`.\n\n Example usage::\n\n @app.route('/wiki/')\n def wiki_page(filename):\n filename = safe_join(app.config['WIKI_FOLDER'], filename)\n with open(filename, 'rb') as fd:\n content = fd.read() # Read and process the file content...\n\n :param directory: the base directory.\n :param filename: the untrusted filename relative to that directory.\n :raises: :class:`~werkzeug.exceptions.NotFound` if the resulting path\n would fall out of `directory`.\n \"\"\"\n filename = posixpath.normpath(filename)\n for sep in _os_alt_seps:\n if sep in filename:\n raise NotFound()\n if os.path.isabs(filename) or \\\n filename == '..' or \\\n filename.startswith('../'):\n raise NotFound()\n return os.path.join(directory, filename)\n\n\ndef send_from_directory(directory, filename, **options):\n \"\"\"Send a file from a given directory with :func:`send_file`. This\n is a secure way to quickly expose static files from an upload folder\n or something similar.\n\n Example usage::\n\n @app.route('/uploads/')\n def download_file(filename):\n return send_from_directory(app.config['UPLOAD_FOLDER'],\n filename, as_attachment=True)\n\n .. admonition:: Sending files and Performance\n\n It is strongly recommended to activate either `X-Sendfile` support in\n your webserver or (if no authentication happens) to tell the webserver\n to serve files for the given path on its own without calling into the\n web application for improved performance.\n\n .. versionadded:: 0.5\n\n :param directory: the directory where all the files are stored.\n :param filename: the filename relative to that directory to\n download.\n :param options: optional keyword arguments that are directly\n forwarded to :func:`send_file`.\n \"\"\"\n filename = safe_join(directory, filename)\n if not os.path.isfile(filename):\n raise NotFound()\n options.setdefault('conditional', True)\n return send_file(filename, **options)\n\n\ndef get_root_path(import_name):\n \"\"\"Returns the path to a package or cwd if that cannot be found. This\n returns the path of a package or the folder that contains a module.\n\n Not to be confused with the package path returned by :func:`find_package`.\n \"\"\"\n # Module already imported and has a file attribute. Use that first.\n mod = sys.modules.get(import_name)\n if mod is not None and hasattr(mod, '__file__'):\n return os.path.dirname(os.path.abspath(mod.__file__))\n\n # Next attempt: check the loader.\n loader = pkgutil.get_loader(import_name)\n\n # Loader does not exist or we're referring to an unloaded main module\n # or a main module without path (interactive sessions), go with the\n # current working directory.\n if loader is None or import_name == '__main__':\n return os.getcwd()\n\n # For .egg, zipimporter does not have get_filename until Python 2.7.\n # Some other loaders might exhibit the same behavior.\n if hasattr(loader, 'get_filename'):\n filepath = loader.get_filename(import_name)\n else:\n # Fall back to imports.\n __import__(import_name)\n filepath = sys.modules[import_name].__file__\n\n # filepath is import_name.py for a module, or __init__.py for a package.\n return os.path.dirname(os.path.abspath(filepath))\n\n\ndef find_package(import_name):\n \"\"\"Finds a package and returns the prefix (or None if the package is\n not installed) as well as the folder that contains the package or\n module as a tuple. The package path returned is the module that would\n have to be added to the pythonpath in order to make it possible to\n import the module. The prefix is the path below which a UNIX like\n folder structure exists (lib, share etc.).\n \"\"\"\n root_mod_name = import_name.split('.')[0]\n loader = pkgutil.get_loader(root_mod_name)\n if loader is None or import_name == '__main__':\n # import name is not found, or interactive/main module\n package_path = os.getcwd()\n else:\n # For .egg, zipimporter does not have get_filename until Python 2.7.\n if hasattr(loader, 'get_filename'):\n filename = loader.get_filename(root_mod_name)\n elif hasattr(loader, 'archive'):\n # zipimporter's loader.archive points to the .egg or .zip\n # archive filename is dropped in call to dirname below.\n filename = loader.archive\n else:\n # At least one loader is missing both get_filename and archive:\n # Google App Engine's HardenedModulesHook\n #\n # Fall back to imports.\n __import__(import_name)\n filename = sys.modules[import_name].__file__\n package_path = os.path.abspath(os.path.dirname(filename))\n # package_path ends with __init__.py for a package\n if loader.is_package(root_mod_name):\n package_path = os.path.dirname(package_path)\n\n site_parent, site_folder = os.path.split(package_path)\n py_prefix = os.path.abspath(sys.prefix)\n if package_path.startswith(py_prefix):\n return py_prefix, package_path\n elif site_folder.lower() == 'site-packages':\n parent, folder = os.path.split(site_parent)\n # Windows like installations\n if folder.lower() == 'lib':\n base_dir = parent\n # UNIX like installations\n elif os.path.basename(parent).lower() == 'lib':\n base_dir = os.path.dirname(parent)\n else:\n base_dir = site_parent\n return base_dir, package_path\n return None, package_path\n\n\nclass locked_cached_property(object):\n \"\"\"A decorator that converts a function into a lazy property. The\n function wrapped is called the first time to retrieve the result\n and then that calculated result is used the next time you access\n the value. Works like the one in Werkzeug but has a lock for\n thread safety.\n \"\"\"\n\n def __init__(self, func, name=None, doc=None):\n self.__name__ = name or func.__name__\n self.__module__ = func.__module__\n self.__doc__ = doc or func.__doc__\n self.func = func\n self.lock = RLock()\n\n def __get__(self, obj, type=None):\n if obj is None:\n return self\n with self.lock:\n value = obj.__dict__.get(self.__name__, _missing)\n if value is _missing:\n value = self.func(obj)\n obj.__dict__[self.__name__] = value\n return value\n\n\nclass _PackageBoundObject(object):\n\n def __init__(self, import_name, template_folder=None):\n #: The name of the package or module. Do not change this once\n #: it was set by the constructor.\n self.import_name = import_name\n\n #: location of the templates. `None` if templates should not be\n #: exposed.\n self.template_folder = template_folder\n\n #: Where is the app root located?\n self.root_path = get_root_path(self.import_name)\n\n self._static_folder = None\n self._static_url_path = None\n\n def _get_static_folder(self):\n if self._static_folder is not None:\n return os.path.join(self.root_path, self._static_folder)\n def _set_static_folder(self, value):\n self._static_folder = value\n static_folder = property(_get_static_folder, _set_static_folder)\n del _get_static_folder, _set_static_folder\n\n def _get_static_url_path(self):\n if self._static_url_path is None:\n if self.static_folder is None:\n return None\n return '/' + os.path.basename(self.static_folder)\n return self._static_url_path\n def _set_static_url_path(self, value):\n self._static_url_path = value\n static_url_path = property(_get_static_url_path, _set_static_url_path)\n del _get_static_url_path, _set_static_url_path\n\n @property\n def has_static_folder(self):\n \"\"\"This is `True` if the package bound object's container has a\n folder named ``'static'``.\n\n .. versionadded:: 0.5\n \"\"\"\n return self.static_folder is not None\n\n @locked_cached_property\n def jinja_loader(self):\n \"\"\"The Jinja loader for this package bound object.\n\n .. versionadded:: 0.5\n \"\"\"\n if self.template_folder is not None:\n return FileSystemLoader(os.path.join(self.root_path,\n self.template_folder))\n\n def get_send_file_max_age(self, filename):\n \"\"\"Provides default cache_timeout for the :func:`send_file` functions.\n\n By default, this function returns ``SEND_FILE_MAX_AGE_DEFAULT`` from\n the configuration of :data:`~flask.current_app`.\n\n Static file functions such as :func:`send_from_directory` use this\n function, and :func:`send_file` calls this function on\n :data:`~flask.current_app` when the given cache_timeout is `None`. If a\n cache_timeout is given in :func:`send_file`, that timeout is used;\n otherwise, this method is called.\n\n This allows subclasses to change the behavior when sending files based\n on the filename. For example, to set the cache timeout for .js files\n to 60 seconds::\n\n class MyFlask(flask.Flask):\n def get_send_file_max_age(self, name):\n if name.lower().endswith('.js'):\n return 60\n return flask.Flask.get_send_file_max_age(self, name)\n\n .. versionadded:: 0.9\n \"\"\"\n return current_app.config['SEND_FILE_MAX_AGE_DEFAULT']\n\n def send_static_file(self, filename):\n \"\"\"Function used internally to send static files from the static\n folder to the browser.\n\n .. versionadded:: 0.5\n \"\"\"\n if not self.has_static_folder:\n raise RuntimeError('No static folder for this object')\n # Ensure get_send_file_max_age is called in all cases.\n # Here, we ensure get_send_file_max_age is called for Blueprints.\n cache_timeout = self.get_send_file_max_age(filename)\n return send_from_directory(self.static_folder, filename,\n cache_timeout=cache_timeout)\n\n def open_resource(self, resource, mode='rb'):\n \"\"\"Opens a resource from the application's resource folder. To see\n how this works, consider the following folder structure::\n\n /myapplication.py\n /schema.sql\n /static\n /style.css\n /templates\n /layout.html\n /index.html\n\n If you want to open the `schema.sql` file you would do the\n following::\n\n with app.open_resource('schema.sql') as f:\n contents = f.read()\n do_something_with(contents)\n\n :param resource: the name of the resource. To access resources within\n subfolders use forward slashes as separator.\n :param mode: resource file opening mode, default is 'rb'.\n \"\"\"\n if mode not in ('r', 'rb'):\n raise ValueError('Resources can only be opened for reading')\n return open(os.path.join(self.root_path, resource), mode)\n" }, { "path": "lib/flask/json.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n flask.jsonimpl\n ~~~~~~~~~~~~~~\n\n Implementation helpers for the JSON support in Flask.\n\n :copyright: (c) 2012 by Armin Ronacher.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nimport io\nimport uuid\nfrom datetime import datetime\nfrom .globals import current_app, request\nfrom ._compat import text_type, PY2\n\nfrom werkzeug.http import http_date\nfrom jinja2 import Markup\n\n# Use the same json implementation as itsdangerous on which we\n# depend anyways.\ntry:\n from itsdangerous import simplejson as _json\nexcept ImportError:\n from itsdangerous import json as _json\n\n\n# figure out if simplejson escapes slashes. This behavior was changed\n# from one version to another without reason.\n_slash_escape = '\\\\/' not in _json.dumps('/')\n\n\n__all__ = ['dump', 'dumps', 'load', 'loads', 'htmlsafe_dump',\n 'htmlsafe_dumps', 'JSONDecoder', 'JSONEncoder',\n 'jsonify']\n\n\ndef _wrap_reader_for_text(fp, encoding):\n if isinstance(fp.read(0), bytes):\n fp = io.TextIOWrapper(io.BufferedReader(fp), encoding)\n return fp\n\n\ndef _wrap_writer_for_text(fp, encoding):\n try:\n fp.write('')\n except TypeError:\n fp = io.TextIOWrapper(fp, encoding)\n return fp\n\n\nclass JSONEncoder(_json.JSONEncoder):\n \"\"\"The default Flask JSON encoder. This one extends the default simplejson\n encoder by also supporting ``datetime`` objects, ``UUID`` as well as\n ``Markup`` objects which are serialized as RFC 822 datetime strings (same\n as the HTTP date format). In order to support more data types override the\n :meth:`default` method.\n \"\"\"\n\n def default(self, o):\n \"\"\"Implement this method in a subclass such that it returns a\n serializable object for ``o``, or calls the base implementation (to\n raise a ``TypeError``).\n\n For example, to support arbitrary iterators, you could implement\n default like this::\n\n def default(self, o):\n try:\n iterable = iter(o)\n except TypeError:\n pass\n else:\n return list(iterable)\n return JSONEncoder.default(self, o)\n \"\"\"\n if isinstance(o, datetime):\n return http_date(o)\n if isinstance(o, uuid.UUID):\n return str(o)\n if hasattr(o, '__html__'):\n return text_type(o.__html__())\n return _json.JSONEncoder.default(self, o)\n\n\nclass JSONDecoder(_json.JSONDecoder):\n \"\"\"The default JSON decoder. This one does not change the behavior from\n the default simplejson encoder. Consult the :mod:`json` documentation\n for more information. This decoder is not only used for the load\n functions of this module but also :attr:`~flask.Request`.\n \"\"\"\n\n\ndef _dump_arg_defaults(kwargs):\n \"\"\"Inject default arguments for dump functions.\"\"\"\n if current_app:\n kwargs.setdefault('cls', current_app.json_encoder)\n if not current_app.config['JSON_AS_ASCII']:\n kwargs.setdefault('ensure_ascii', False)\n kwargs.setdefault('sort_keys', current_app.config['JSON_SORT_KEYS'])\n else:\n kwargs.setdefault('sort_keys', True)\n kwargs.setdefault('cls', JSONEncoder)\n\n\ndef _load_arg_defaults(kwargs):\n \"\"\"Inject default arguments for load functions.\"\"\"\n if current_app:\n kwargs.setdefault('cls', current_app.json_decoder)\n else:\n kwargs.setdefault('cls', JSONDecoder)\n\n\ndef dumps(obj, **kwargs):\n \"\"\"Serialize ``obj`` to a JSON formatted ``str`` by using the application's\n configured encoder (:attr:`~flask.Flask.json_encoder`) if there is an\n application on the stack.\n\n This function can return ``unicode`` strings or ascii-only bytestrings by\n default which coerce into unicode strings automatically. That behavior by\n default is controlled by the ``JSON_AS_ASCII`` configuration variable\n and can be overriden by the simplejson ``ensure_ascii`` parameter.\n \"\"\"\n _dump_arg_defaults(kwargs)\n encoding = kwargs.pop('encoding', None)\n rv = _json.dumps(obj, **kwargs)\n if encoding is not None and isinstance(rv, text_type):\n rv = rv.encode(encoding)\n return rv\n\n\ndef dump(obj, fp, **kwargs):\n \"\"\"Like :func:`dumps` but writes into a file object.\"\"\"\n _dump_arg_defaults(kwargs)\n encoding = kwargs.pop('encoding', None)\n if encoding is not None:\n fp = _wrap_writer_for_text(fp, encoding)\n _json.dump(obj, fp, **kwargs)\n\n\ndef loads(s, **kwargs):\n \"\"\"Unserialize a JSON object from a string ``s`` by using the application's\n configured decoder (:attr:`~flask.Flask.json_decoder`) if there is an\n application on the stack.\n \"\"\"\n _load_arg_defaults(kwargs)\n if isinstance(s, bytes):\n s = s.decode(kwargs.pop('encoding', None) or 'utf-8')\n return _json.loads(s, **kwargs)\n\n\ndef load(fp, **kwargs):\n \"\"\"Like :func:`loads` but reads from a file object.\n \"\"\"\n _load_arg_defaults(kwargs)\n if not PY2:\n fp = _wrap_reader_for_text(fp, kwargs.pop('encoding', None) or 'utf-8')\n return _json.load(fp, **kwargs)\n\n\ndef htmlsafe_dumps(obj, **kwargs):\n \"\"\"Works exactly like :func:`dumps` but is safe for use in ``')\n self.assert_equal(rv, u'\"\\\\u003c/script\\\\u003e\"')\n self.assert_equal(type(rv), text_type)\n rv = render('{{ \"\"|tojson }}')\n self.assert_equal(rv, '\"\\\\u003c/script\\\\u003e\"')\n rv = render('{{ \"<\\0/script>\"|tojson }}')\n self.assert_equal(rv, '\"\\\\u003c\\\\u0000/script\\\\u003e\"')\n rv = render('{{ \"' % (\n render_traceback(self, full=full),\n self.render_as_text().decode('utf-8', 'replace')\n )\n\n @property\n def is_template_syntax_error(self):\n \"\"\"`True` if this is a template syntax error.\"\"\"\n return isinstance(self.exc_value, TemplateSyntaxError)\n\n @property\n def exc_info(self):\n \"\"\"Exception info tuple with a proxy around the frame objects.\"\"\"\n return self.exc_type, self.exc_value, self.frames[0]\n\n @property\n def standard_exc_info(self):\n \"\"\"Standard python exc_info for re-raising\"\"\"\n tb = self.frames[0]\n # the frame will be an actual traceback (or transparent proxy) if\n # we are on pypy or a python implementation with support for tproxy\n if type(tb) is not TracebackType:\n tb = tb.tb\n return self.exc_type, self.exc_value, tb\n\n\ndef make_traceback(exc_info, source_hint=None):\n \"\"\"Creates a processed traceback object from the exc_info.\"\"\"\n exc_type, exc_value, tb = exc_info\n if isinstance(exc_value, TemplateSyntaxError):\n exc_info = translate_syntax_error(exc_value, source_hint)\n initial_skip = 0\n else:\n initial_skip = 1\n return translate_exception(exc_info, initial_skip)\n\n\ndef translate_syntax_error(error, source=None):\n \"\"\"Rewrites a syntax error to please traceback systems.\"\"\"\n error.source = source\n error.translated = True\n exc_info = (error.__class__, error, None)\n filename = error.filename\n if filename is None:\n filename = ''\n return fake_exc_info(exc_info, filename, error.lineno)\n\n\ndef translate_exception(exc_info, initial_skip=0):\n \"\"\"If passed an exc_info it will automatically rewrite the exceptions\n all the way down to the correct line numbers and frames.\n \"\"\"\n tb = exc_info[2]\n frames = []\n\n # skip some internal frames if wanted\n for x in range(initial_skip):\n if tb is not None:\n tb = tb.tb_next\n initial_tb = tb\n\n while tb is not None:\n # skip frames decorated with @internalcode. These are internal\n # calls we can't avoid and that are useless in template debugging\n # output.\n if tb.tb_frame.f_code in internal_code:\n tb = tb.tb_next\n continue\n\n # save a reference to the next frame if we override the current\n # one with a faked one.\n next = tb.tb_next\n\n # fake template exceptions\n template = tb.tb_frame.f_globals.get('__jinja_template__')\n if template is not None:\n lineno = template.get_corresponding_lineno(tb.tb_lineno)\n tb = fake_exc_info(exc_info[:2] + (tb,), template.filename,\n lineno)[2]\n\n frames.append(make_frame_proxy(tb))\n tb = next\n\n # if we don't have any exceptions in the frames left, we have to\n # reraise it unchanged.\n # XXX: can we backup here? when could this happen?\n if not frames:\n reraise(exc_info[0], exc_info[1], exc_info[2])\n\n return ProcessedTraceback(exc_info[0], exc_info[1], frames)\n\n\ndef fake_exc_info(exc_info, filename, lineno):\n \"\"\"Helper for `translate_exception`.\"\"\"\n exc_type, exc_value, tb = exc_info\n\n # figure the real context out\n if tb is not None:\n real_locals = tb.tb_frame.f_locals.copy()\n ctx = real_locals.get('context')\n if ctx:\n locals = ctx.get_all()\n else:\n locals = {}\n for name, value in iteritems(real_locals):\n if name.startswith('l_') and value is not missing:\n locals[name[2:]] = value\n\n # if there is a local called __jinja_exception__, we get\n # rid of it to not break the debug functionality.\n locals.pop('__jinja_exception__', None)\n else:\n locals = {}\n\n # assamble fake globals we need\n globals = {\n '__name__': filename,\n '__file__': filename,\n '__jinja_exception__': exc_info[:2],\n\n # we don't want to keep the reference to the template around\n # to not cause circular dependencies, but we mark it as Jinja\n # frame for the ProcessedTraceback\n '__jinja_template__': None\n }\n\n # and fake the exception\n code = compile('\\n' * (lineno - 1) + raise_helper, filename, 'exec')\n\n # if it's possible, change the name of the code. This won't work\n # on some python environments such as google appengine\n try:\n if tb is None:\n location = 'template'\n else:\n function = tb.tb_frame.f_code.co_name\n if function == 'root':\n location = 'top-level template code'\n elif function.startswith('block_'):\n location = 'block \"%s\"' % function[6:]\n else:\n location = 'template'\n\n if PY2:\n code = CodeType(0, code.co_nlocals, code.co_stacksize,\n code.co_flags, code.co_code, code.co_consts,\n code.co_names, code.co_varnames, filename,\n location, code.co_firstlineno,\n code.co_lnotab, (), ())\n else:\n code = CodeType(0, code.co_kwonlyargcount,\n code.co_nlocals, code.co_stacksize,\n code.co_flags, code.co_code, code.co_consts,\n code.co_names, code.co_varnames, filename,\n location, code.co_firstlineno,\n code.co_lnotab, (), ())\n except Exception as e:\n pass\n\n # execute the code and catch the new traceback\n try:\n exec(code, globals, locals)\n except:\n exc_info = sys.exc_info()\n new_tb = exc_info[2].tb_next\n\n # return without this frame\n return exc_info[:2] + (new_tb,)\n\n\ndef _init_ugly_crap():\n \"\"\"This function implements a few ugly things so that we can patch the\n traceback objects. The function returned allows resetting `tb_next` on\n any python traceback object. Do not attempt to use this on non cpython\n interpreters\n \"\"\"\n import ctypes\n from types import TracebackType\n\n if PY2:\n # figure out size of _Py_ssize_t for Python 2:\n if hasattr(ctypes.pythonapi, 'Py_InitModule4_64'):\n _Py_ssize_t = ctypes.c_int64\n else:\n _Py_ssize_t = ctypes.c_int\n else:\n # platform ssize_t on Python 3\n _Py_ssize_t = ctypes.c_ssize_t\n\n # regular python\n class _PyObject(ctypes.Structure):\n pass\n _PyObject._fields_ = [\n ('ob_refcnt', _Py_ssize_t),\n ('ob_type', ctypes.POINTER(_PyObject))\n ]\n\n # python with trace\n if hasattr(sys, 'getobjects'):\n class _PyObject(ctypes.Structure):\n pass\n _PyObject._fields_ = [\n ('_ob_next', ctypes.POINTER(_PyObject)),\n ('_ob_prev', ctypes.POINTER(_PyObject)),\n ('ob_refcnt', _Py_ssize_t),\n ('ob_type', ctypes.POINTER(_PyObject))\n ]\n\n class _Traceback(_PyObject):\n pass\n _Traceback._fields_ = [\n ('tb_next', ctypes.POINTER(_Traceback)),\n ('tb_frame', ctypes.POINTER(_PyObject)),\n ('tb_lasti', ctypes.c_int),\n ('tb_lineno', ctypes.c_int)\n ]\n\n def tb_set_next(tb, next):\n \"\"\"Set the tb_next attribute of a traceback object.\"\"\"\n if not (isinstance(tb, TracebackType) and\n (next is None or isinstance(next, TracebackType))):\n raise TypeError('tb_set_next arguments must be traceback objects')\n obj = _Traceback.from_address(id(tb))\n if tb.tb_next is not None:\n old = _Traceback.from_address(id(tb.tb_next))\n old.ob_refcnt -= 1\n if next is None:\n obj.tb_next = ctypes.POINTER(_Traceback)()\n else:\n next = _Traceback.from_address(id(next))\n next.ob_refcnt += 1\n obj.tb_next = ctypes.pointer(next)\n\n return tb_set_next\n\n\n# try to get a tb_set_next implementation if we don't have transparent\n# proxies.\ntb_set_next = None\nif tproxy is None:\n try:\n tb_set_next = _init_ugly_crap()\n except:\n pass\n del _init_ugly_crap\n" }, { "path": "lib/jinja2/defaults.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n jinja2.defaults\n ~~~~~~~~~~~~~~~\n\n Jinja default filters and tags.\n\n :copyright: (c) 2010 by the Jinja Team.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nfrom jinja2._compat import range_type\nfrom jinja2.utils import generate_lorem_ipsum, Cycler, Joiner\n\n\n# defaults for the parser / lexer\nBLOCK_START_STRING = '{%'\nBLOCK_END_STRING = '%}'\nVARIABLE_START_STRING = '{{'\nVARIABLE_END_STRING = '}}'\nCOMMENT_START_STRING = '{#'\nCOMMENT_END_STRING = '#}'\nLINE_STATEMENT_PREFIX = None\nLINE_COMMENT_PREFIX = None\nTRIM_BLOCKS = False\nLSTRIP_BLOCKS = False\nNEWLINE_SEQUENCE = '\\n'\nKEEP_TRAILING_NEWLINE = False\n\n\n# default filters, tests and namespace\nfrom jinja2.filters import FILTERS as DEFAULT_FILTERS\nfrom jinja2.tests import TESTS as DEFAULT_TESTS\nDEFAULT_NAMESPACE = {\n 'range': range_type,\n 'dict': dict,\n 'lipsum': generate_lorem_ipsum,\n 'cycler': Cycler,\n 'joiner': Joiner\n}\n\n\n# export all constants\n__all__ = tuple(x for x in locals().keys() if x.isupper())\n" }, { "path": "lib/jinja2/environment.py", "content": "# -*- coding: utf-8 -*-\n\"\"\"\n jinja2.environment\n ~~~~~~~~~~~~~~~~~~\n\n Provides a class that holds runtime and parsing time options.\n\n :copyright: (c) 2010 by the Jinja Team.\n :license: BSD, see LICENSE for more details.\n\"\"\"\nimport os\nimport sys\nfrom jinja2 import nodes\nfrom jinja2.defaults import BLOCK_START_STRING, \\\n BLOCK_END_STRING, VARIABLE_START_STRING, VARIABLE_END_STRING, \\\n COMMENT_START_STRING, COMMENT_END_STRING, LINE_STATEMENT_PREFIX, \\\n LINE_COMMENT_PREFIX, TRIM_BLOCKS, NEWLINE_SEQUENCE, \\\n DEFAULT_FILTERS, DEFAULT_TESTS, DEFAULT_NAMESPACE, \\\n KEEP_TRAILING_NEWLINE, LSTRIP_BLOCKS\nfrom jinja2.lexer import get_lexer, TokenStream\nfrom jinja2.parser import Parser\nfrom jinja2.nodes import EvalContext\nfrom jinja2.optimizer import optimize\nfrom jinja2.compiler import generate, CodeGenerator\nfrom jinja2.runtime import Undefined, new_context, Context\nfrom jinja2.exceptions import TemplateSyntaxError, TemplateNotFound, \\\n TemplatesNotFound, TemplateRuntimeError\nfrom jinja2.utils import import_string, LRUCache, Markup, missing, \\\n concat, consume, internalcode\nfrom jinja2._compat import imap, ifilter, string_types, iteritems, \\\n text_type, reraise, implements_iterator, implements_to_string, \\\n get_next, encode_filename, PY2, PYPY\nfrom functools import reduce\n\n\n# for direct template usage we have up to ten living environments\n_spontaneous_environments = LRUCache(10)\n\n# the function to create jinja traceback objects. This is dynamically\n# imported on the first exception in the exception handler.\n_make_traceback = None\n\n\ndef get_spontaneous_environment(*args):\n \"\"\"Return a new spontaneous environment. A spontaneous environment is an\n unnamed and unaccessible (in theory) environment that is used for\n templates generated from a string and not from the file system.\n \"\"\"\n try:\n env = _spontaneous_environments.get(args)\n except TypeError:\n return Environment(*args)\n if env is not None:\n return env\n _spontaneous_environments[args] = env = Environment(*args)\n env.shared = True\n return env\n\n\ndef create_cache(size):\n \"\"\"Return the cache class for the given size.\"\"\"\n if size == 0:\n return None\n if size < 0:\n return {}\n return LRUCache(size)\n\n\ndef copy_cache(cache):\n \"\"\"Create an empty copy of the given cache.\"\"\"\n if cache is None:\n return None\n elif type(cache) is dict:\n return {}\n return LRUCache(cache.capacity)\n\n\ndef load_extensions(environment, extensions):\n \"\"\"Load the extensions from the list and bind it to the environment.\n Returns a dict of instantiated environments.\n \"\"\"\n result = {}\n for extension in extensions:\n if isinstance(extension, string_types):\n extension = import_string(extension)\n result[extension.identifier] = extension(environment)\n return result\n\n\ndef _environment_sanity_check(environment):\n \"\"\"Perform a sanity check on the environment.\"\"\"\n assert issubclass(environment.undefined, Undefined), 'undefined must ' \\\n 'be a subclass of undefined because filters depend on it.'\n assert environment.block_start_string != \\\n environment.variable_start_string != \\\n environment.comment_start_string, 'block, variable and comment ' \\\n 'start strings must be different'\n assert environment.newline_sequence in ('\\r', '\\r\\n', '\\n'), \\\n 'newline_sequence set to unknown line ending string.'\n return environment\n\n\nclass Environment(object):\n r\"\"\"The core component of Jinja is the `Environment`. It contains\n important shared variables like configuration, filters, tests,\n globals and others. Instances of this class may be modified if\n they are not shared and if no template was loaded so far.\n Modifications on environments after the first template was loaded\n will lead to surprising effects and undefined behavior.\n\n Here are the possible initialization parameters:\n\n `block_start_string`\n The string marking the beginning of a block. Defaults to ``'{%'``.\n\n `block_end_string`\n The string marking the end of a block. Defaults to ``'%}'``.\n\n `variable_start_string`\n The string marking the beginning of a print statement.\n Defaults to ``'{{'``.\n\n `variable_end_string`\n The string marking the end of a print statement. Defaults to\n ``'}}'``.\n\n `comment_start_string`\n The string marking the beginning of a comment. Defaults to ``'{#'``.\n\n `comment_end_string`\n The string marking the end of a comment. Defaults to ``'#}'``.\n\n `line_statement_prefix`\n If given and a string, this will be used as prefix for line based\n statements. See also :ref:`line-statements`.\n\n `line_comment_prefix`\n If given and a string, this will be used as prefix for line based\n comments. See also :ref:`line-statements`.\n\n .. versionadded:: 2.2\n\n `trim_blocks`\n If this is set to ``True`` the first newline after a block is\n removed (block, not variable tag!). Defaults to `False`.\n\n `lstrip_blocks`\n If this is set to ``True`` leading spaces and tabs are stripped\n from the start of a line to a block. Defaults to `False`.\n\n `newline_sequence`\n The sequence that starts a newline. Must be one of ``'\\r'``,\n ``'\\n'`` or ``'\\r\\n'``. The default is ``'\\n'`` which is a\n useful default for Linux and OS X systems as well as web\n applications.\n\n `keep_trailing_newline`\n Preserve the trailing newline when rendering templates.\n The default is ``False``, which causes a single newline,\n if present, to be stripped from the end of the template.\n\n .. versionadded:: 2.7\n\n `extensions`\n List of Jinja extensions to use. This can either be import paths\n as strings or extension classes. For more information have a\n look at :ref:`the extensions documentation `.\n\n `optimized`\n should the optimizer be enabled? Default is `True`.\n\n `undefined`\n :class:`Undefined` or a subclass of it that is used to represent\n undefined values in the template.\n\n `finalize`\n A callable that can be used to process the result of a variable\n expression before it is output. For example one can convert\n `None` implicitly into an empty string here.\n\n `autoescape`\n If set to true the XML/HTML autoescaping feature is enabled by\n default. For more details about autoescaping see\n :class:`~jinja2.utils.Markup`. As of Jinja 2.4 this can also\n be a callable that is passed the template name and has to\n return `True` or `False` depending on autoescape should be\n enabled by default.\n\n .. versionchanged:: 2.4\n `autoescape` can now be a function\n\n `loader`\n The template loader for this environment.\n\n `cache_size`\n The size of the cache. Per default this is ``400`` which means\n that if more than 400 templates are loaded the loader will clean\n out the least recently used template. If the cache size is set to\n ``0`` templates are recompiled all the time, if the cache size is\n ``-1`` the cache will not be cleaned.\n\n .. versionchanged:: 2.8\n The cache size was increased to 400 from a low 50.\n\n `auto_reload`\n Some loaders load templates from locations where the template\n sources may change (ie: file system or database). If\n `auto_reload` is set to `True` (default) every time a template is\n requested the loader checks if the source changed and if yes, it\n will reload the template. For higher performance it's possible to\n disable that.\n\n `bytecode_cache`\n If set to a bytecode cache object, this object will provide a\n cache for the internal Jinja bytecode so that templates don't\n have to be parsed if they were not changed.\n\n See :ref:`bytecode-cache` for more information.\n \"\"\"\n\n #: if this environment is sandboxed. Modifying this variable won't make\n #: the environment sandboxed though. For a real sandboxed environment\n #: have a look at jinja2.sandbox. This flag alone controls the code\n #: generation by the compiler.\n sandboxed = False\n\n #: True if the environment is just an overlay\n overlayed = False\n\n #: the environment this environment is linked to if it is an overlay\n linked_to = None\n\n #: shared environments have this set to `True`. A shared environment\n #: must not be modified\n shared = False\n\n #: these are currently EXPERIMENTAL undocumented features.\n exception_handler = None\n exception_formatter = None\n\n #: the class that is used for code generation. See\n #: :class:`~jinja2.compiler.CodeGenerator` for more information.\n code_generator_class = CodeGenerator\n\n #: the context class thatis used for templates. See\n #: :class:`~jinja2.runtime.Context` for more information.\n context_class = Context\n\n def __init__(self,\n block_start_string=BLOCK_START_STRING,\n block_end_string=BLOCK_END_STRING,\n variable_start_string=VARIABLE_START_STRING,\n variable_end_string=VARIABLE_END_STRING,\n comment_start_string=COMMENT_START_STRING,\n comment_end_string=COMMENT_END_STRING,\n line_statement_prefix=LINE_STATEMENT_PREFIX,\n line_comment_prefix=LINE_COMMENT_PREFIX,\n trim_blocks=TRIM_BLOCKS,\n lstrip_blocks=LSTRIP_BLOCKS,\n newline_sequence=NEWLINE_SEQUENCE,\n keep_trailing_newline=KEEP_TRAILING_NEWLINE,\n extensions=(),\n optimized=True,\n undefined=Undefined,\n finalize=None,\n autoescape=False,\n loader=None,\n cache_size=400,\n auto_reload=True,\n bytecode_cache=None):\n # !!Important notice!!\n # The constructor accepts quite a few arguments that should be\n # passed by keyword rather than position. However it's important to\n # not change the order of arguments because it's used at least\n # internally in those cases:\n # - spontaneous environments (i18n extension and Template)\n # - unittests\n # If parameter changes are required only add parameters at the end\n # and don't change the arguments (or the defaults!) of the arguments\n # existing already.\n\n # lexer / parser information\n self.block_start_string = block_start_string\n self.block_end_string = block_end_string\n self.variable_start_string = variable_start_string\n self.variable_end_string = variable_end_string\n self.comment_start_string = comment_start_string\n self.comment_end_string = comment_end_string\n self.line_statement_prefix = line_statement_prefix\n self.line_comment_prefix = line_comment_prefix\n self.trim_blocks = trim_blocks\n self.lstrip_blocks = lstrip_blocks\n self.newline_sequence = newline_sequence\n self.keep_trailing_newline = keep_trailing_newline\n\n # runtime information\n self.undefined = undefined\n self.optimized = optimized\n self.finalize = finalize\n self.autoescape = autoescape\n\n # defaults\n self.filters = DEFAULT_FILTERS.copy()\n self.tests = DEFAULT_TESTS.copy()\n self.globals = DEFAULT_NAMESPACE.copy()\n\n # set the loader provided\n self.loader = loader\n self.cache = create_cache(cache_size)\n self.bytecode_cache = bytecode_cache\n self.auto_reload = auto_reload\n\n # load extensions\n self.extensions = load_extensions(self, extensions)\n\n _environment_sanity_check(self)\n\n def add_extension(self, extension):\n \"\"\"Adds an extension after the environment was created.\n\n .. versionadded:: 2.5\n \"\"\"\n self.extensions.update(load_extensions(self, [extension]))\n\n def extend(self, **attributes):\n \"\"\"Add the items to the instance of the environment if they do not exist\n yet. This is used by :ref:`extensions ` to register\n callbacks and configuration values without breaking inheritance.\n \"\"\"\n for key, value in iteritems(attributes):\n if not hasattr(self, key):\n setattr(self, key, value)\n\n def overlay(self, block_start_string=missing, block_end_string=missing,\n variable_start_string=missing, variable_end_string=missing,\n comment_start_string=missing, comment_end_string=missing,\n line_statement_prefix=missing, line_comment_prefix=missing,\n trim_blocks=missing, lstrip_blocks=missing,\n extensions=missing, optimized=missing,\n undefined=missing, finalize=missing, autoescape=missing,\n loader=missing, cache_size=missing, auto_reload=missing,\n bytecode_cache=missing):\n \"\"\"Create a new overlay environment that shares all the data with the\n current environment except for cache and the overridden attributes.\n Extensions cannot be removed for an overlayed environment. An overlayed\n environment automatically gets all the extensions of the environment it\n is linked to plus optional extra extensions.\n\n Creating overlays should happen after the initial environment was set\n up completely. Not all attributes are truly linked, some are just\n copied over so modifications on the original environment may not shine\n through.\n \"\"\"\n args = dict(locals())\n del args['self'], args['cache_size'], args['extensions']\n\n rv = object.__new__(self.__class__)\n rv.__dict__.update(self.__dict__)\n rv.overlayed = True\n rv.linked_to = self\n\n for key, value in iteritems(args):\n if value is not missing:\n setattr(rv, key, value)\n\n if cache_size is not missing:\n rv.cache = create_cache(cache_size)\n else:\n rv.cache = copy_cache(self.cache)\n\n rv.extensions = {}\n for key, value in iteritems(self.extensions):\n rv.extensions[key] = value.bind(rv)\n if extensions is not missing:\n rv.extensions.update(load_extensions(rv, extensions))\n\n return _environment_sanity_check(rv)\n\n lexer = property(get_lexer, doc=\"The lexer for this environment.\")\n\n def iter_extensions(self):\n \"\"\"Iterates over the extensions by priority.\"\"\"\n return iter(sorted(self.extensions.values(),\n key=lambda x: x.priority))\n\n def getitem(self, obj, argument):\n \"\"\"Get an item or attribute of an object but prefer the item.\"\"\"\n try:\n return obj[argument]\n except (TypeError, LookupError):\n if isinstance(argument, string_types):\n try:\n attr = str(argument)\n except Exception:\n pass\n else:\n try:\n return getattr(obj, attr)\n except AttributeError:\n pass\n return self.undefined(obj=obj, name=argument)\n\n def getattr(self, obj, attribute):\n \"\"\"Get an item or attribute of an object but prefer the attribute.\n Unlike :meth:`getitem` the attribute *must* be a bytestring.\n \"\"\"\n try:\n return getattr(obj, attribute)\n except AttributeError:\n pass\n try:\n return obj[attribute]\n except (TypeError, LookupError, AttributeError):\n return self.undefined(obj=obj, name=attribute)\n\n def call_filter(self, name, value, args=None, kwargs=None,\n context=None, eval_ctx=None):\n \"\"\"Invokes a filter on a value the same way the compiler does it.\n\n .. versionadded:: 2.7\n \"\"\"\n func = self.filters.get(name)\n if func is None:\n raise TemplateRuntimeError('no filter named %r' % name)\n args = [value] + list(args or ())\n if getattr(func, 'contextfilter', False):\n if context is None:\n raise TemplateRuntimeError('Attempted to invoke context '\n 'filter without context')\n args.insert(0, context)\n elif getattr(func, 'evalcontextfilter', False):\n if eval_ctx is None:\n if context is not None:\n eval_ctx = context.eval_ctx\n else:\n eval_ctx = EvalContext(self)\n args.insert(0, eval_ctx)\n elif getattr(func, 'environmentfilter', False):\n args.insert(0, self)\n return func(*args, **(kwargs or {}))\n\n def call_test(self, name, value, args=None, kwargs=None):\n \"\"\"Invokes a test on a value the same way the compiler does it.\n\n .. versionadded:: 2.7\n \"\"\"\n func = self.tests.get(name)\n if func is None:\n raise TemplateRuntimeError('no test named %r' % name)\n return func(value, *(args or ()), **(kwargs or {}))\n\n @internalcode\n def parse(self, source, name=None, filename=None):\n \"\"\"Parse the sourcecode and return the abstract syntax tree. This\n tree of nodes is used by the compiler to convert the template into\n executable source- or bytecode. This is useful for debugging or to\n extract information from templates.\n\n If you are :ref:`developing Jinja2 extensions `\n this gives you a good overview of the node tree generated.\n \"\"\"\n try:\n return self._parse(source, name, filename)\n except TemplateSyntaxError:\n exc_info = sys.exc_info()\n self.handle_exception(exc_info, source_hint=source)\n\n def _parse(self, source, name, filename):\n \"\"\"Internal parsing function used by `parse` and `compile`.\"\"\"\n return Parser(self, source, name, encode_filename(filename)).parse()\n\n def lex(self, source, name=None, filename=None):\n \"\"\"Lex the given sourcecode and return a generator that yields\n tokens as tuples in the form ``(lineno, token_type, value)``.\n This can be useful for :ref:`extension development `\n and debugging templates.\n\n This does not perform preprocessing. If you want the preprocessing\n of the extensions to be applied you have to filter source through\n the :meth:`preprocess` method.\n \"\"\"\n source = text_type(source)\n try:\n return self.lexer.tokeniter(source, name, filename)\n except TemplateSyntaxError:\n exc_info = sys.exc_info()\n self.handle_exception(exc_info, source_hint=source)\n\n def preprocess(self, source, name=None, filename=None):\n \"\"\"Preprocesses the source with all extensions. This is automatically\n called for all parsing and compiling methods but *not* for :meth:`lex`\n because there you usually only want the actual source tokenized.\n \"\"\"\n return reduce(lambda s, e: e.preprocess(s, name, filename),\n self.iter_extensions(), text_type(source))\n\n def _tokenize(self, source, name, filename=None, state=None):\n \"\"\"Called by the parser to do the preprocessing and filtering\n for all the extensions. Returns a :class:`~jinja2.lexer.TokenStream`.\n \"\"\"\n source = self.preprocess(source, name, filename)\n stream = self.lexer.tokenize(source, name, filename, state)\n for ext in self.iter_extensions():\n stream = ext.filter_stream(stream)\n if not isinstance(stream, TokenStream):\n stream = TokenStream(stream, name, filename)\n return stream\n\n def _generate(self, source, name, filename, defer_init=False):\n \"\"\"Internal hook that can be overridden to hook a different generate\n method in.\n\n .. versionadded:: 2.5\n \"\"\"\n return generate(source, self, name, filename, defer_init=defer_init)\n\n def _compile(self, source, filename):\n \"\"\"Internal hook that can be overridden to hook a different compile\n method in.\n\n .. versionadded:: 2.5\n \"\"\"\n return compile(source, filename, 'exec')\n\n @internalcode\n def compile(self, source, name=None, filename=None, raw=False,\n defer_init=False):\n \"\"\"Compile a node or template source code. The `name` parameter is\n the load name of the template after it was joined using\n :meth:`join_path` if necessary, not the filename on the file system.\n the `filename` parameter is the estimated filename of the template on\n the file system. If the template came from a database or memory this\n can be omitted.\n\n The return value of this method is a python code object. If the `raw`\n parameter is `True` the return value will be a string with python\n code equivalent to the bytecode returned otherwise. This method is\n mainly used internally.\n\n `defer_init` is use internally to aid the module code generator. This\n causes the generated code to be able to import without the global\n environment variable to be set.\n\n .. versionadded:: 2.4\n `defer_init` parameter added.\n \"\"\"\n source_hint = None\n try:\n if isinstance(source, string_types):\n source_hint = source\n source = self._parse(source, name, filename)\n if self.optimized:\n source = optimize(source, self)\n source = self._generate(source, name, filename,\n defer_init=defer_init)\n if raw:\n return source\n if filename is None:\n filename = '