Flask

https://flask.palletsprojects.com/en/stable/
Admin
Flask is a lightweight WSGI web application framework designed for quick and easy development,...
Tokens:249,280
Snippets:2,236
Trust Score:9.9
Update:5 days ago
Show doc for...
Tokens:
Raw
### Example factory and dispatcher setup for path-based dispatch

Source: https://flask.palletsprojects.com/en/stable/patterns/appdispatch

Shows how to create a factory function that returns an app for a given prefix or None, and how to instantiate the PathDispatcher with a default app and this factory.

```python
from myapplication import create_app, default_app, get_user_for_prefix

def make_app(prefix):
    user = get_user_for_prefix(prefix)
    if user is not None:
        return create_app(user)

application = PathDispatcher(default_app, make_app)

```

--------------------------------

### Run the application with waitress-serve --call 'flaskr:create_app'

Source: https://flask.palletsprojects.com/en/stable/tutorial/deploy

Start Waitress, telling it to import and call the application factory. The example output is 'Serving on http://0.0.0.0:8080'.

```bash
$ waitress-serve --call 'flaskr:create_app'

Serving on http://0.0.0.0:8080

```

--------------------------------

### Install Waitress in a virtualenv

Source: https://flask.palletsprojects.com/en/stable/deploying/waitress

Create a virtualenv, install your application, then install waitress. The command sequence assumes you are in the hello-app directory.

```bash
$ cd hello-app
$ python -m venv .venv
$ . .venv/bin/activate
$ pip install .  # install your application
$ pip install waitress
```

--------------------------------

### Install uwsgi or pyuwsgi from sdist

Source: https://flask.palletsprojects.com/en/stable/deploying/uwsgi

If you have a compiler available, you can install the uwsgi package or install pyuwsgi from sdist. Either method includes SSL support.

```bash
$ pip install uwsgi

# or
$ pip install --no-binary pyuwsgi pyuwsgi

```

--------------------------------

### Install Waitress with pip install waitress

Source: https://flask.palletsprojects.com/en/stable/tutorial/deploy

Install the Waitress production WSGI server in the virtual environment.

```bash
$ pip install waitress

```

--------------------------------

### Run Celery worker command

Source: https://flask.palletsprojects.com/en/stable/patterns/celery

Start a Celery worker for the example app with INFO logging.

```bash
$ celery -A example worker --loglevel INFO

```

--------------------------------

### Example views.py for package

Source: https://flask.palletsprojects.com/en/stable/patterns/packages

Defines a route using the application instance imported from the package.

```python
from yourapplication import app

@app.route('/')
def index():
    return 'Hello World!'

```

--------------------------------

### Install Flask with pip

Source: https://flask.palletsprojects.com/en/stable/installation

Installs Flask within the activated virtual environment using pip. After installation, Flask is ready to use.

```bash
$ pip install Flask
```

--------------------------------

### Install pyuwsgi in a virtualenv

Source: https://flask.palletsprojects.com/en/stable/deploying/uwsgi

Create a virtualenv, install your application, then install pyuwsgi. This method provides precompiled wheels for common platforms but does not include SSL support.

```bash
$ cd hello-app
$ python -m venv .venv
$ . .venv/bin/activate
$ pip install .  # install your application
$ pip install pyuwsgi

```

--------------------------------

### Install pytest

Source: https://flask.palletsprojects.com/en/stable/testing

Command to install the pytest framework, which is used to set up and run tests for Flask applications.

```bash
$ pip install pytest
```

--------------------------------

### Example Flask configuration file

Source: https://flask.palletsprojects.com/en/stable/config

Example configuration file with a SECRET_KEY. Only uppercase values are stored in the config object, so use uppercase for config keys.

```python
# Example configuration
SECRET_KEY = '192b9bdd22ab9ed4d12e236c78afcb9a393ec15f71bbf5dc987d54727823bcbf'

```

--------------------------------

### Install Celery with pip

Source: https://flask.palletsprojects.com/en/stable/patterns/celery

Install Celery from PyPI using pip.

```bash
$ pip install celery

```

--------------------------------

### Install Gunicorn in a virtualenv

Source: https://flask.palletsprojects.com/en/stable/deploying/gunicorn

Commands to create a virtualenv, install your application, and install Gunicorn. Gunicorn runs on Windows only under WSL.

```bash
$ cd hello-app
$ python -m venv .venv
$ . .venv/bin/activate
$ pip install .  # install your application
$ pip install gunicorn
```

--------------------------------

### Install application in editable mode

Source: https://flask.palletsprojects.com/en/stable/patterns/packages

Command to install the package in editable mode so it can be imported.

```bash
$ pip install -e .

```

--------------------------------

### Configure MongoEngine with Flask

Source: https://flask.palletsprojects.com/en/stable/patterns/mongoengine

Basic setup by defining MONGODB_SETTINGS on app.config and creating a MongoEngine instance.

```python
from flask import Flask
from flask_mongoengine import MongoEngine

app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
    "db": "myapp",
}
db = MongoEngine(app)
```

--------------------------------

### Install and run custom Flask CLI script

Source: https://flask.palletsprojects.com/en/stable/cli

Installs the application in editable mode and runs the custom script. Note that '--app' is not needed.

```bash
$ pip install -e .
$ wiki run

```

--------------------------------

### Start mod_wsgi-express with 4 processes

Source: https://flask.palletsprojects.com/en/stable/deploying/mod_wsgi

Runs the server with the --processes option to set the number of worker processes; a starting value could be CPU * 2. Logs are not shown in the terminal; errors go to the error log file.

```bash
$ mod_wsgi-express start-server wsgi.py --processes 4

```

--------------------------------

### Run the gevent server

Source: https://flask.palletsprojects.com/en/stable/deploying/gevent

Command to execute the wsgi.py script. No output is shown when the server starts.

```bash
$ python wsgi.py

```

--------------------------------

### Separate views for GET and POST using shortcut decorators

Source: https://flask.palletsprojects.com/en/stable/quickstart

Flask provides shortcut decorators like get() and post() to separate views for different HTTP methods into different functions. This example shows separate functions for GET and POST on the same route.

```python
@app.get('/login')
def login_get():
    return show_the_login_form()

@app.post('/login')
def login_post():
    return do_the_login()

```

--------------------------------

### Create and enter the flask-tutorial directory

Source: https://flask.palletsprojects.com/en/stable/tutorial/layout

Run these shell commands to create and enter the project directory. The tutorial assumes you work from this directory for all subsequent steps.

```bash
$ mkdir flask-tutorial
$ cd flask-tutorial

```

--------------------------------

### Handling POST and GET requests with form data

Source: https://flask.palletsprojects.com/en/stable/quickstart

Example route that handles both POST and GET requests. It checks the request method, validates form data, and returns a login page or an error message.

```python
@app.route('/login', methods=['POST', 'GET'])
def login():
    error = None
    if request.method == 'POST':
        if valid_login(request.form['username'],
                       request.form['password']):
            return log_the_user_in(request.form['username'])
        else:
            error = 'Invalid username/password'
    # the code below is executed if the request method
    # was GET or the credentials were invalid
    return render_template('login.html', error=error)
```

--------------------------------

### Run uWSGI with basic options

Source: https://flask.palletsprojects.com/en/stable/deploying/uwsgi

Starts an HTTP server on 127.0.0.1:8000 with 4 worker processes and imports the hello:app application. The output shows the server startup messages.

```bash
$ uwsgi --http 127.0.0.1:8000 --master -p 4 -w hello:app

*** Starting uWSGI 2.0.20 (64bit) on [x] ***
*** Operational MODE: preforking ***
mounting hello:app on /
spawned uWSGI master process (pid: x)
spawned uWSGI worker 1 (pid: x, cores: 1)
spawned uWSGI worker 2 (pid: x, cores: 1)
spawned uWSGI worker 3 (pid: x, cores: 1)
spawned uWSGI worker 4 (pid: x, cores: 1)
spawned uWSGI http 1 (pid: x)

```

--------------------------------

### MethodView subclass for REST API with get and post

Source: https://flask.palletsprojects.com/en/stable/api

Subclass flask.views.MethodView to handle HTTP methods via instance methods. methods is automatically set based on defined methods. Example shows get and post methods using session and redirect.

```python
class CounterAPI(MethodView):
    def get(self):
        return str(session.get("counter", 0))

    def post(self):
        session["counter"] = session.get("counter", 0) + 1
        return redirect(url_for("counter"))

app.add_url_rule(
    "/counter", view_func=CounterAPI.as_view("counter")
)
```

--------------------------------

### Blueprint.make_setup_state(app, options, first_registration=False)

Source: https://flask.palletsprojects.com/en/stable/api

Creates an instance of BlueprintSetupState() object that is later passed to the register callback functions. Subclasses can override this to return a subclass of the setup state.

```APIDOC
## Blueprint.make_setup_state(app, options, first_registration=False)

### Description
Creates an instance of `BlueprintSetupState()` object that is later passed to the register callback functions. Subclasses can override this to return a subclass of the setup state.

### Parameters
- **app** (App) - Required - The application object.
- **options** (dict[str, t.Any]) - Required - Options dictionary.
- **first_registration** (bool) - Optional - Whether this is the first registration.

### Return Type
`BlueprintSetupState`
```

--------------------------------

### Handle GET and POST methods in a single route function

Source: https://flask.palletsprojects.com/en/stable/quickstart

Use the methods argument of the route() decorator to handle multiple HTTP methods in one function. This is useful when each method shares common data. The example checks request.method to return different responses for POST and GET.

```python
from flask import request

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        return do_the_login()
    else:
        return show_the_login_form()

```

--------------------------------

### Create and configure Flask application

Source: https://flask.palletsprojects.com/en/stable/lifecycle

Shows the initial setup of a Flask application: creating the app instance, loading configuration from a mapping and environment variables, and defining a route. This code must be completed before serving requests.

```python
from flask import Flask

app = Flask(__name__)
app.config.from_mapping(
    SECRET_KEY="dev",
)
app.config.from_prefixed_env()

@app.route("/")
def index():
    return "Hello, World!"

```

--------------------------------

### Define Task with @shared_task

Source: https://flask.palletsprojects.com/en/stable/patterns/celery

Use Celery's @shared_task decorator to define tasks that access the current app, avoiding issues with the factory pattern. This example sets ignore_result=False to get the return value.

```python
from celery import shared_task

@shared_task(ignore_result=False)
def add_together(a: int, b: int) -> int:
    return a + b

```

--------------------------------

### Load config from module and instance file

Source: https://flask.palletsprojects.com/en/stable/config

Full example of preloading config from a module and overriding with a file from the instance folder if it exists.

```python
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('yourapplication.default_settings')
app.config.from_pyfile('application.cfg', silent=True)

```

--------------------------------

### Example __init__.py for package

Source: https://flask.palletsprojects.com/en/stable/patterns/packages

Creates the Flask application object and imports views module at the bottom to avoid circular import issues.

```python
from flask import Flask
app = Flask(__name__)

import yourapplication.views

```

--------------------------------

### copy_current_request_context decorator for background tasks

Source: https://flask.palletsprojects.com/en/stable/api

Decorates a function to run inside the current request context, allowing access to flask.request and flask.session in a background task. The example uses gevent.spawn to start the task. Warning: read request data before starting the task or use a lock to avoid partial reads; access session in the parent to set the Vary: cookie header.

```python
import gevent
from flask import copy_current_request_context

@app.route('/')
def index():
    @copy_current_request_context
    def do_some_work():
        # do some work here, it can access flask.request or
        # flask.session like you would otherwise in the view function.
        ...
    gevent.spawn(do_some_work)
    return 'Regular response'
```

--------------------------------

### Test user endpoint using user_set context manager

Source: https://flask.palletsprojects.com/en/stable/api

Example test code that uses the user_set context manager to set the user to 'john' and then makes a GET request to '/users/me', asserting the response data.

```python
def test_user_me(self):
    with user_set(app, 'john'):
        c = app.test_client()
        resp = c.get('/users/me')
        assert resp.data == 'username=john'

```

--------------------------------

### Route decorator example

Source: https://flask.palletsprojects.com/en/stable/api

Shows how to use the @app.route decorator to register a view function for the root URL. The endpoint name defaults to the view function name, and methods default to GET with HEAD and OPTIONS added automatically.

```python
@app.route("/")
def index():
    return "Hello, World!"

```

--------------------------------

### Using SubdomainDispatcher with create_app and get_user_for_subdomain

Source: https://flask.palletsprojects.com/en/stable/patterns/appdispatch

Example of how to instantiate the SubdomainDispatcher with a factory function that returns a WSGI application for a given subdomain. If no user exists for the subdomain, it returns a NotFound() exception as the application, which renders a default 404 page.

```python
from myapplication import create_app, get_user_for_subdomain
from werkzeug.exceptions import NotFound

def make_app(subdomain):
    user = get_user_for_subdomain(subdomain)
    if user is None:
        # if there is no user for that subdomain we still have
        # to return a WSGI application that handles that request.
        # We can then just return the NotFound() exception as
        # application which will render a default 404 page.
        # You might also redirect the user to the main page then
        return NotFound()

    # otherwise create the application for the specific user
    return create_app(user)

application = SubdomainDispatcher('example.com', make_app)

```

--------------------------------

### Fetch Celery task result with AsyncResult in a Flask route

Source: https://flask.palletsprojects.com/en/stable/patterns/celery

Use AsyncResult with the result ID to check if the task is ready, successful, and get its return value or error. Poll this route after starting the task to avoid blocking Flask request workers.

```python
from celery.result import AsyncResult

@app.get("/result/<id>")
def task_result(id: str) -> dict[str, object]:
    result = AsyncResult(id)
    return {
        "ready": result.ready(),
        "successful": result.successful(),
        "value": result.result if result.ready() else None,
    }

```

--------------------------------

### Run Flask app with --app option

Source: https://flask.palletsprojects.com/en/stable/quickstart

Starts the built-in development server for the app in hello.py. The output shows the server URL and the CTRL+C quit instruction.

```bash
$ flask --app hello run
 * Serving Flask app 'hello'
 * Running on http://127.0.0.1:5000 (Press CTRL+C to quit)

```

--------------------------------

### Install the wheel file with pip install flaskr-1.0.0-py3-none-any.whl

Source: https://flask.palletsprojects.com/en/stable/tutorial/deploy

Copy the wheel file to another machine, set up a new virtualenv, and install it with pip. Pip will install the project along with its dependencies.

```bash
$ pip install flaskr-1.0.0-py3-none-any.whl

```

--------------------------------

### Run init_db from Python shell

Source: https://flask.palletsprojects.com/en/stable/patterns/sqlite3

Shows how to import and call the init_db function from a Python shell to create the database. The output is not shown, but the command is expected to run without errors.

```python
>>> from yourapplication import init_db
>>> init_db()

```

--------------------------------

### Blueprint with URL processors and prefix

Source: https://flask.palletsprojects.com/en/stable/patterns/urlprocessors

Blueprint example using url_prefix and per-blueprint URL processors to handle language codes automatically.

```python
from flask import Blueprint, g

bp = Blueprint('frontend', __name__, url_prefix='/<lang_code>')

@bp.url_defaults
def add_language_code(endpoint, values):
    values.setdefault('lang_code', g.lang_code)

@bp.url_value_preprocessor
def pull_lang_code(endpoint, values):
    g.lang_code = values.pop('lang_code')

@bp.route('/')
def index():
    ...

@bp.route('/about')
def about():
    ...

```

--------------------------------

### Using a Flask extension (Flask-Foo)

Source: https://flask.palletsprojects.com/en/stable/extensions

Shows the typical pattern for using a Flask extension: import the extension class, create an instance, configure it via app.config, and initialize it with the app using init_app().

```python
from flask_foo import Foo

foo = Foo()

app = Flask(__name__)
app.config.update(
    FOO_BAR='baz',
    FOO_SPAM='eggs',
)

foo.init_app(app)

```

--------------------------------

### Example User model in models.py

Source: https://flask.palletsprojects.com/en/stable/patterns/sqlalchemy

Defines a User model with id, name, and email columns. The __init__ method sets name and email, and __repr__ returns a string representation.

```python
from sqlalchemy import Column, Integer, String
from yourapplication.database import Base

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), unique=True)
    email = Column(String(120), unique=True)

    def __init__(self, name=None, email=None):
        self.name = name
        self.email = email

    def __repr__(self):
        return f'<User {self.name!r}>'
```

--------------------------------

### pip list output showing installed flaskr

Source: https://flask.palletsprojects.com/en/stable/tutorial/install

Shows the expected output of pip list after installation, confirming flaskr is installed with its location.

```text
$ pip list

Package        Version   Location
-------------- --------- ----------------------------------
click          6.7
Flask          1.0
flaskr         1.0.0     /home/user/Projects/flask-tutorial
itsdangerous   0.24
Jinja2         2.10
MarkupSafe     1.0
pip            9.0.3
Werkzeug       0.14.1

```

--------------------------------

### Register the blog blueprint in flaskr/__init__.py

Source: https://flask.palletsprojects.com/en/stable/tutorial/blog

Shows how to import and register the blog blueprint in the application factory. Also adds a URL rule for the index endpoint. Place this code at the end of create_app() before returning the app.

```python
def create_app():
    app = ...
    # existing code omitted

    from . import blog
    app.register_blueprint(blog.bp)
    app.add_url_rule('/', endpoint='index')

    return app

```

--------------------------------

### Install mod_wsgi in a virtualenv

Source: https://flask.palletsprojects.com/en/stable/deploying/mod_wsgi

Create a virtualenv, install your application, then install mod_wsgi. Requires a compiler and Apache development headers; otherwise an error occurs.

```bash
$ cd hello-app
$ python -m venv .venv
$ . .venv/bin/activate
$ pip install .  # install your application
$ pip install mod_wsgi

```

--------------------------------

### Initial Flask application structure

Source: https://flask.palletsprojects.com/en/stable/patterns/packages

Shows the simple Flask application layout before converting to a package.

```text
/yourapplication
    yourapplication.py
    /static
        style.css
    /templates
        layout.html
        index.html
        login.html
        ...

```

--------------------------------

### Install gevent in a virtualenv

Source: https://flask.palletsprojects.com/en/stable/deploying/gevent

Commands to create a virtualenv, install your application, and install gevent. Requires greenlet>=1.0 and PyPy>=7.3.7 when using PyPy.

```bash
$ cd hello-app
$ python -m venv .venv
$ . .venv/bin/activate
$ pip install .  # install your application
$ pip install gevent

```

--------------------------------

### Instantiate configuration class before from_object()

Source: https://flask.palletsprojects.com/en/stable/config

Shows how to instantiate a configuration class before passing it to from_object(), either by direct import or via import_string. This is required to access properties.

```python
from configmodule import ProductionConfig
app.config.from_object(ProductionConfig())

# Alternatively, import via string:
from werkzeug.utils import import_string
cfg = import_string('configmodule.ProductionConfig')()
app.config.from_object(cfg)

```

--------------------------------

### Run the init-db command

Source: https://flask.palletsprojects.com/en/stable/tutorial/database

Run the flask --app flaskr init-db command to initialize the database. The expected output is 'Initialized the database.' and a flaskr.sqlite file is created in the instance folder.

```bash
$ flask --app flaskr init-db
Initialized the database.

```

--------------------------------

### Install Flask-MongoEngine

Source: https://flask.palletsprojects.com/en/stable/patterns/mongoengine

Install the required Flask-MongoEngine package using pip.

```bash
pip install flask-mongoengine
```

--------------------------------

### Set config options and retrieve namespace with get_namespace

Source: https://flask.palletsprojects.com/en/stable/api

Sets three IMAGE_STORE_* config options and retrieves them as a dictionary with the namespace trimmed and keys lowercased. The resulting dictionary is shown in the second block.

```python
app.config['IMAGE_STORE_TYPE'] = 'fs'
app.config['IMAGE_STORE_PATH'] = '/var/app/images'
app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
image_store_config = app.config.get_namespace('IMAGE_STORE_')

```

```python
{
    'type': 'fs',
    'path': '/var/app/images',
    'base_url': 'http://img.website.com'
}

```

--------------------------------

### Default route with GET and POST methods

Source: https://flask.palletsprojects.com/en/stable/api

Shows a route with a default value and methods=['GET', 'POST']. The default route should only handle GET to avoid redirects losing form data.

```python
@app.route('/region/', defaults={'id': 1})
@app.route('/region/<int:id>', methods=['GET', 'POST'])
def region(id):
   pass

```

--------------------------------

### Install pytest and coverage

Source: https://flask.palletsprojects.com/en/stable/tutorial/tests

Command to install pytest and coverage using pip.

```bash
$ pip install pytest coverage

```

--------------------------------

### Insert entries into the database

Source: https://flask.palletsprojects.com/en/stable/patterns/sqlalchemy

Shows how to create a User instance, add it to the session, and commit to persist it.

```python
>>> from yourapplication.database import db_session
>>> from yourapplication.models import User
>>> u = User('admin', 'admin@localhost')
>>> db_session.add(u)
>>> db_session.commit()
```

--------------------------------

### Run Waitress with waitress-serve (app and factory)

Source: https://flask.palletsprojects.com/en/stable/deploying/waitress

The only required argument to waitress-serve is {module}:{app}. Use --call for the app factory pattern. The --host option binds to local 127.0.0.1 only. The output shows the server serving on http://127.0.0.1:8080.

```bash
# equivalent to 'from hello import app'
$ waitress-serve --host 127.0.0.1 hello:app

# equivalent to 'from hello import create_app; create_app()'
$ waitress-serve --host 127.0.0.1 --call hello:create_app

Serving on http://127.0.0.1:8080
```

--------------------------------

### Create a LocalProxy from get_db()

Source: https://flask.palletsprojects.com/en/stable/appcontext

Use werkzeug.local.LocalProxy to create a context local proxy from get_db(). Accessing db will call get_db internally, similar to how current_app works.

```python
from werkzeug.local import LocalProxy
db = LocalProxy(get_db)

```

--------------------------------

### Complete application with URL processors

Source: https://flask.palletsprojects.com/en/stable/patterns/urlprocessors

Full application example combining url_defaults and url_value_preprocessor to remove repetitive language code handling from view functions.

```python
from flask import Flask, g

app = Flask(__name__)

@app.url_defaults
def add_language_code(endpoint, values):
    if 'lang_code' in values or not g.lang_code:
        return
    if app.url_map.is_endpoint_expecting(endpoint, 'lang_code'):
        values['lang_code'] = g.lang_code

@app.url_value_preprocessor
def pull_lang_code(endpoint, values):
    g.lang_code = values.pop('lang_code', None)

@app.route('/<lang_code>/')
def index():
    ...

@app.route('/<lang_code>/about')
def about():
    ...

```

--------------------------------

### Flask.get

Source: https://flask.palletsprojects.com/en/stable/api

Shortcut for `route()` with `methods=["GET"]`. Registers a route for the GET HTTP method.

```APIDOC
## Flask.get

### Description
Shortcut for `route()` with `methods=["GET"]`. Registers a route for the GET HTTP method.

### Method
get

### Parameters
- **rule** (_str_) - The URL rule as string.
- **options** (_Any_) - Additional options passed to the route.

### Return Type
_Callable_[[_T_route_], _T_route_]
```

--------------------------------

### Install Sentry SDK with Flask dependencies

Source: https://flask.palletsprojects.com/en/stable/errorhandling

Install the sentry-sdk client with the flask extra dependencies using pip.

```bash
$ pip install sentry-sdk[flask]
```

--------------------------------

### database.py module for declarative SQLAlchemy setup

Source: https://flask.palletsprojects.com/en/stable/patterns/sqlalchemy

Sets up the SQLAlchemy engine, scoped session, and declarative base. The init_db function creates all tables and requires importing model modules before calling it.

```python
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker, declarative_base

engine = create_engine('sqlite:////tmp/test.db')
db_session = scoped_session(sessionmaker(autocommit=False,
                                         autoflush=False,
                                         bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()

def init_db():
    # import all modules here that might define models so that
    # they will be registered properly on the metadata.  Otherwise
    # you will have to import them first before calling init_db()
    import yourapplication.models
    Base.metadata.create_all(bind=engine)
```

--------------------------------

### Blueprint.get(rule, **options)

Source: https://flask.palletsprojects.com/en/stable/api

Shortcut for route() with methods=["GET"]. Registers a view function for GET requests on the given rule.

```APIDOC
## Blueprint.get(rule, **options)

### Description
Shortcut for `route()` with `methods=["GET"]`.

### Method
GET

### Endpoint
`/rule` (path parameter)

### Parameters
#### Path Parameters
- **rule** (str) - Required - The URL rule as string.

#### Options
- **options** (Any) - Optional - Additional options passed to `route()`.

### Return Type
`Callable[[T_route], T_route]`
```

--------------------------------

### Class-based views with model passed to as_view

Source: https://flask.palletsprojects.com/en/stable/extensiondev

Shows how to define a Post model and a MethodView that receives the model via as_view(). The BlogExtension creates the model in __init__ and passes it to the view in init_app.

```python
class PostAPI(MethodView):
    def __init__(self, model):
        self.model = model

    def get(self, id):
        post = self.model.query.get(id)
        return jsonify(post.to_json())

class BlogExtension:
    def __init__(self, db):
        class Post(db.Model):
            id = db.Column(primary_key=True)
            title = db.Column(db.String, nullable=False)

        self.post_model = Post

    def init_app(self, app):
        api_view = PostAPI.as_view(model=self.post_model)

db = SQLAlchemy()
blog = BlogExtension(db)
db.init_app(app)
blog.init_app(app)
```

--------------------------------

### Subscribe to got_request_exception signal

Source: https://flask.palletsprojects.com/en/stable/api

Example subscriber for the got_request_exception signal, which is sent when an unhandled exception occurs during request processing. This example logs a SecurityException.

```python
from flask import got_request_exception

def log_security_exception(sender, exception, **extra):
    if not isinstance(exception, SecurityException):
        return

    security_logger.exception(
        f"SecurityException at {request.url!r}",
        exc_info=exception,
    )

got_request_exception.connect(log_security_exception, app)

```

--------------------------------

### Correct extension initialization in model.py

Source: https://flask.palletsprojects.com/en/stable/patterns/appfactories

Shows the recommended way to initialize an extension: create the extension object without binding it to an app, then call init_app later.

```python
db = SQLAlchemy()

```

--------------------------------

### Basic GET request with client.get()

Source: https://flask.palletsprojects.com/en/stable/testing

Use client.get() to send a GET request to a route. The response.data contains the bytes returned by the view, which can be checked with assertions.

```python
def test_request_example(client):
    response = client.get("/posts")
    assert b"<h2>Hello, World!</h2>" in response.data

```

--------------------------------

### Access instance_path and open_instance_resource

Source: https://flask.palletsprojects.com/en/stable/config

Shows two ways to read a file from the instance folder: using os.path.join with app.instance_path, or using app.open_instance_resource().

```python
filename = os.path.join(app.instance_path, 'application.cfg')
with open(filename) as f:
    config = f.read()

# or via open_instance_resource:
with app.open_instance_resource('application.cfg') as f:
    config = f.read()

```
Tokens:
Raw