| Flask Extension Development |
| =========================== |
|
|
| Flask, being a microframework, often requires some repetitive steps to get |
| a third party library working. Many such extensions are already available |
| on `PyPI`_. |
|
|
| If you want to create your own Flask extension for something that does not |
| exist yet, this guide to extension development will help you get your |
| extension running in no time and to feel like users would expect your |
| extension to behave. |
|
|
| Anatomy of an Extension |
| |
|
|
| Extensions are all located in a package called ``flask_something`` |
| where "something" is the name of the library you want to bridge. So for |
| example if you plan to add support for a library named `simplexml` to |
| Flask, you would name your extension's package ``flask_simplexml``. |
|
|
| The name of the actual extension (the human readable name) however would |
| be something like "Flask-SimpleXML". Make sure to include the name |
| "Flask" somewhere in that name and that you check the capitalization. |
| This is how users can then register dependencies to your extension in |
| their :file:`setup.py` files. |
|
|
| But what do extensions look like themselves? An extension has to ensure |
| that it works with multiple Flask application instances at once. This is |
| a requirement because many people will use patterns like the |
| :doc:`/patterns/appfactories` pattern to create their application as |
| needed to aid unittests and to support multiple configurations. Because |
| of that it is crucial that your application supports that kind of |
| behavior. |
|
|
| Most importantly the extension must be shipped with a :file:`setup.py` file and |
| registered on PyPI. Also the development checkout link should work so |
| that people can easily install the development version into their |
| virtualenv without having to download the library by hand. |
|
|
| Flask extensions must be licensed under a BSD, MIT or more liberal license |
| in order to be listed in the Flask Extension Registry. Keep in mind |
| that the Flask Extension Registry is a moderated place and libraries will |
| be reviewed upfront if they behave as required. |
|
|
| "Hello Flaskext!" |
| |
|
|
| So let's get started with creating such a Flask extension. The extension |
| we want to create here will provide very basic support for SQLite3. |
|
|
| First we create the following folder structure:: |
|
|
| flask-sqlite3/ |
| flask_sqlite3.py |
| LICENSE |
| README |
|
|
| Here's the contents of the most important files: |
|
|
| setup.py |
| ```````` |
|
|
| The next file that is absolutely required is the :file:`setup.py` file which is |
| used to install your Flask extension. The following contents are |
| something you can work with:: |
|
|
| """ |
| Flask-SQLite3 |
| ------------- |
| |
| This is the description for that library |
| """ |
| from setuptools import setup |
|
|
|
|
| setup( |
| name='Flask-SQLite3', |
| version='1.0', |
| url='http://example.com/flask-sqlite3/', |
| license='BSD', |
| author='Your Name', |
| author_email='your-email@example.com', |
| description='Very short description', |
| long_description=__doc__, |
| py_modules=['flask_sqlite3'], |
| |
| |
| |
| zip_safe=False, |
| include_package_data=True, |
| platforms='any', |
| install_requires=[ |
| 'Flask' |
| ], |
| classifiers=[ |
| 'Environment :: Web Environment', |
| 'Intended Audience :: Developers', |
| 'License :: OSI Approved :: BSD License', |
| 'Operating System :: OS Independent', |
| 'Programming Language :: Python', |
| 'Topic :: Internet :: WWW/HTTP :: Dynamic Content', |
| 'Topic :: Software Development :: Libraries :: Python Modules' |
| ] |
| ) |
|
|
| That's a lot of code but you can really just copy/paste that from existing |
| extensions and adapt. |
|
|
| flask_sqlite3.py |
| ```````````````` |
|
|
| Now this is where your extension code goes. But how exactly should such |
| an extension look like? What are the best practices? Continue reading |
| for some insight. |
|
|
| Initializing Extensions |
| |
|
|
| Many extensions will need some kind of initialization step. For example, |
| consider an application that's currently connecting to SQLite like the |
| documentation suggests (:doc:`/patterns/sqlite3`). So how does the |
| extension know the name of the application object? |
|
|
| Quite simple: you pass it to it. |
|
|
| There are two recommended ways for an extension to initialize: |
|
|
| initialization functions: |
|
|
| If your extension is called `helloworld` you might have a function |
| called ``init_helloworld(app[, extra_args])`` that initializes the |
| extension for that application. It could attach before / after |
| handlers etc. |
|
|
| classes: |
|
|
| Classes work mostly like initialization functions but can later be |
| used to further change the behavior. |
|
|
| What to use depends on what you have in mind. For the SQLite 3 extension |
| we will use the class-based approach because it will provide users with an |
| object that handles opening and closing database connections. |
|
|
| When designing your classes, it's important to make them easily reusable |
| at the module level. This means the object itself must not under any |
| circumstances store any application specific state and must be shareable |
| between different applications. |
|
|
| The Extension Code |
| |
|
|
| Here's the contents of the `flask_sqlite3.py` for copy/paste:: |
|
|
| import sqlite3 |
| from flask import current_app, _app_ctx_stack |
|
|
|
|
| class SQLite3(object): |
| def __init__(self, app=None): |
| self.app = app |
| if app is not None: |
| self.init_app(app) |
|
|
| def init_app(self, app): |
| app.config.setdefault('SQLITE3_DATABASE', ':memory:') |
| app.teardown_appcontext(self.teardown) |
|
|
| def connect(self): |
| return sqlite3.connect(current_app.config['SQLITE3_DATABASE']) |
|
|
| def teardown(self, exception): |
| ctx = _app_ctx_stack.top |
| if hasattr(ctx, 'sqlite3_db'): |
| ctx.sqlite3_db.close() |
|
|
| @property |
| def connection(self): |
| ctx = _app_ctx_stack.top |
| if ctx is not None: |
| if not hasattr(ctx, 'sqlite3_db'): |
| ctx.sqlite3_db = self.connect() |
| return ctx.sqlite3_db |
|
|
|
|
| So here's what these lines of code do: |
|
|
| 1. The ``__init__`` method takes an optional app object and, if supplied, will |
| call ``init_app``. |
| 2. The ``init_app`` method exists so that the ``SQLite3`` object can be |
| instantiated without requiring an app object. This method supports the |
| factory pattern for creating applications. The ``init_app`` will set the |
| configuration for the database, defaulting to an in memory database if |
| no configuration is supplied. In addition, the ``init_app`` method |
| attaches the ``teardown`` handler. |
| 3. Next, we define a ``connect`` method that opens a database connection. |
| 4. Finally, we add a ``connection`` property that on first access opens |
| the database connection and stores it on the context. This is also |
| the recommended way to handling resources: fetch resources lazily the |
| first time they are used. |
|
|
| Note here that we're attaching our database connection to the top |
| application context via ``_app_ctx_stack.top``. Extensions should use |
| the top context for storing their own information with a sufficiently |
| complex name. |
|
|
| So why did we decide on a class-based approach here? Because using our |
| extension looks something like this:: |
|
|
| from flask import Flask |
| from flask_sqlite3 import SQLite3 |
|
|
| app = Flask(__name__) |
| app.config.from_pyfile('the-config.cfg') |
| db = SQLite3(app) |
|
|
| You can then use the database from views like this:: |
|
|
| @app.route('/') |
| def show_all(): |
| cur = db.connection.cursor() |
| cur.execute(...) |
|
|
| Likewise if you are outside of a request you can use the database by |
| pushing an app context:: |
|
|
| with app.app_context(): |
| cur = db.connection.cursor() |
| cur.execute(...) |
|
|
| At the end of the ``with`` block the teardown handles will be executed |
| automatically. |
|
|
| Additionally, the ``init_app`` method is used to support the factory pattern |
| for creating apps:: |
|
|
| db = SQLite3() |
| |
| app = create_app('the-config.cfg') |
| db.init_app(app) |
|
|
| Keep in mind that supporting this factory pattern for creating apps is required |
| for approved flask extensions (described below). |
|
|
| .. admonition:: Note on ``init_app`` |
|
|
| As you noticed, ``init_app`` does not assign ``app`` to ``self``. This |
| is intentional! Class based Flask extensions must only store the |
| application on the object when the application was passed to the |
| constructor. This tells the extension: I am not interested in using |
| multiple applications. |
|
|
| When the extension needs to find the current application and it does |
| not have a reference to it, it must either use the |
| :data:`~flask.current_app` context local or change the API in a way |
| that you can pass the application explicitly. |
|
|
|
|
| Using _app_ctx_stack |
| |
|
|
| In the example above, before every request, a ``sqlite3_db`` variable is |
| assigned to ``_app_ctx_stack.top``. In a view function, this variable is |
| accessible using the ``connection`` property of ``SQLite3``. During the |
| teardown of a request, the ``sqlite3_db`` connection is closed. By using |
| this pattern, the *same* connection to the sqlite3 database is accessible |
| to anything that needs it for the duration of the request. |
|
|
|
|
| Learn from Others |
| |
|
|
| This documentation only touches the bare minimum for extension development. |
| If you want to learn more, it's a very good idea to check out existing extensions |
| on the `PyPI`_. If you feel lost there is still the `mailinglist`_ and the |
| `Discord server`_ to get some ideas for nice looking APIs. Especially if you do |
| something nobody before you did, it might be a very good idea to get some more |
| input. This not only generates useful feedback on what people might want from |
| an extension, but also avoids having multiple developers working in isolation |
| on pretty much the same problem. |
|
|
| Remember: good API design is hard, so introduce your project on the |
| mailing list, and let other developers give you a helping hand with |
| designing the API. |
|
|
| The best Flask extensions are extensions that share common idioms for the |
| API. And this can only work if collaboration happens early. |
|
|
| Approved Extensions |
| |
|
|
| Flask previously had the concept of approved extensions. These came with |
| some vetting of support and compatibility. While this list became too |
| difficult to maintain over time, the guidelines are still relevant to |
| all extensions maintained and developed today, as they help the Flask |
| ecosystem remain consistent and compatible. |
|
|
| 0. An approved Flask extension requires a maintainer. In the event an |
| extension author would like to move beyond the project, the project |
| should find a new maintainer and transfer access to the repository, |
| documentation, PyPI, and any other services. If no maintainer |
| is available, give access to the Pallets core team. |
| 1. The naming scheme is *Flask-ExtensionName* or *ExtensionName-Flask*. |
| It must provide exactly one package or module named |
| ``flask_extension_name``. |
| 2. The extension must be BSD or MIT licensed. It must be open source |
| and publicly available. |
| 3. The extension's API must have the following characteristics: |
|
|
| - It must support multiple applications running in the same Python |
| process. Use ``current_app`` instead of ``self.app``, store |
| configuration and state per application instance. |
| - It must be possible to use the factory pattern for creating |
| applications. Use the ``ext.init_app()`` pattern. |
|
|
| 4. From a clone of the repository, an extension with its dependencies |
| must be installable with ``pip install -e .``. |
| 5. It must ship a testing suite that can be invoked with ``tox -e py`` |
| or ``pytest``. If not using ``tox``, the test dependencies should be |
| specified in a ``requirements.txt`` file. The tests must be part of |
| the sdist distribution. |
| 6. The documentation must use the ``flask`` theme from the |
| `Official Pallets Themes`_. A link to the documentation or project |
| website must be in the PyPI metadata or the readme. |
| 7. For maximum compatibility, the extension should support the same |
| versions of Python that Flask supports. 3.7+ is recommended as of |
| December 2021. Use ``python_requires=">= 3.7"`` in ``setup.py`` to |
| indicate supported versions. |
|
|
| .. _PyPI: https://pypi.org/search/?c=Framework+%3A%3A+Flask |
| .. _mailinglist: https://mail.python.org/mailman/listinfo/flask |
| .. _Discord server: https://discord.gg/pallets |
| .. _Official Pallets Themes: https://pypi.org/project/Pallets-Sphinx-Themes/ |
|
|
