Сообщить об ошибке.

Аргументы конструктора Flask() модуля flask в Python.

Синтаксис:

import flask

app = flask.Flask(import_name, static_url_path=None, 
                  static_folder='static', static_host=None, 
                  host_matching=False, subdomain_matching=False, 
                  template_folder='templates', instance_path=None, 
                  instance_relative_config=False, root_path=None)

Параметры:

  • import_name - строка с именем пакета приложения Flask.
  • static_url_path=None - может использоваться для указания другого пути статических файлов в интернете. По умолчанию используется имя папки static_folder.
  • static_folder='static' - папка со статическими файлами, которая обслуживается по static_url_path. Может указываться относительно root_path приложения или как абсолютный путь. По умолчанию 'static'.
  • static_host=None - строка с именем хоста, который будет использоваться при добавлении статического маршрута. По умолчанию None. Требуется при использовании host_matching=True и настроенной static_folder.
  • host_matching=False - устанавливает атрибут url_map.host_matching. По умолчанию False.
  • subdomain_matching=False - при сопоставлении маршрутов учитывает субдомен относительно SERVER_NAME. По умолчанию False.
  • template_folder='templates' - папка, содержащая шаблоны, которые будет использовать приложение Flask. По умолчанию папка 'templates' находится в корневом каталоге приложения.
  • instance_path=None - альтернативный путь к экземпляру приложения. По умолчанию предполагается, что папка instance находится рядом с пакетом или модулем и является путем к экземпляру.
  • instance_relative_config=False - если установлено значение True, то относительные имена файлов для загрузки конфигурации считаются относительными к пути экземпляра, а не к корню приложения.
  • root_path=None - путь к корню приложения Flask. Его следует устанавливать вручную только в том случае, если он не может быть обнаружен автоматически, например, для пакетов пространств имен.

Возвращаемое значение:

Описание:

Класс Flask() модуля flask создает объект Flask, который реализует приложение WSGI и действует как главный, центральный объект.

В конструктор класса передается имя модуля или пакета приложения import_name. После создания объект приложения будет действовать как центральный реестр для функций-представлений, правил URL-адресов, конфигурации шаблона и многого другого.

Имя пакета import_name используется для разрешения ресурсов внутри пакета или папки, в которой содержится модуль, в зависимости от того, соответствует ли параметр пакета фактическому пакету Python (папка с файлом __init__.py внутри) или стандартному модулю (просто файл c расширением .py).

Дополнительные сведения о загрузке ресурсов смотрите в описании метода Flask.open_resource()

Обычно, экземпляр Flask создается в своем основном модуле или в файле __init__.py своего пакета следующим образом:

from flask import Flask
app = Flask(__name__)

О первом параметре import_name:

Идея первого параметра import_name состоит в том, чтобы дать приложению Flask представление о том, что ему принадлежит. Это имя используется для поиска ресурсов в файловой системе, может использоваться расширениями для улучшения отладочной информации и многого другого.

Поэтому важно, что там предоставляется. Если приложение Flask состоит из одного модуля, то значение __name__ всегда будет правильным значением. НО если приложение Flask представляет собой пакет, то рекомендуется жестко указать имя этого пакета в аргументе import_name.

Например, если приложение Flask определено в yourapplication/app.py, то необходимо создать его с помощью одной из двух версий ниже:

app = Flask('yourapplication')
# или
app = Flask(__name__.split('.')[0])

Почему именно так? Приложение будет работать даже с __name__, благодаря тому, как ищутся ресурсы. Однако, это сделает отладку более болезненной. Некоторые расширения делают предположения на основе импортированного имени приложения. Например, расширение Flask-SQLAlchemy будет искать в приложении код, который запускал SQL-запрос в режиме отладки. Если имя импорта не задано должным образом, то эта отладочная информация теряется. Например, он будет обрабатывать только SQL-запросы в yourapplication.app, а не yourapplication.views.frontend.

Атрибуты и методы объекта Flask.


Flask.add_template_filter(f, name=None):

Метод Flask.add_template_filter() регистрирует пользовательский фильтр f для шаблона jinja2. Работает точно так же, как декоратор @Flask.template_filter().

Необязательный аргумент name - это строка с именем фильтра. Если отсутствует, то будет использоваться имя функции.

Flask.add_template_global(f, name=None):

Метод Flask.add_template_global() регистрирует глобальную функцию f для [шаблона jinja2][]. Работает точно так же, как декоратор @Flask.template_global().

Необязательный аргумент name - это строка с именем глобальной функции. Если отсутствует, то будет использоваться имя функции.

Flask.add_template_test(f, name=None):

Метод Flask.add_template_test() регистрирует пользовательский тест f для шаблона jinja2. Работает точно так же, как декоратор @Flask.template_test().

Необязательный аргумент name - это строка с именем теста. Если отсутствует, то будет использоваться имя функции.

Flask.add_url_rule(rule, endpoint=None, view_func=None, provide_automatic_options=None, **options):

Декоратор Flask.add_url_rule() регистрирует правило для маршрутизации входящих запросов и построения URL-адресов. Декоратор @Flask.route() - это ссылка для вызова этого метода с аргументом view_func. Они эквивалентны:

@app.route("/")
def index():
    ...

# эквивалентно
def index():
    ...

app.add_url_rule("/", view_func=index)

Смотрите раздел "Декоратор @route() и метод add_url_rule() приложения Flask".

Если аргумент endpoint не передан, то качестве имени конечной точки для маршрута используется имя функции-представления. Если функция-представление уже была зарегистрирована для конечной точки, то будет вызвана ошибка.

По умолчанию, для аргумента methods установлено значение ['GET']. HEAD всегда добавляется автоматически, а OPTIONS добавляется автоматически по умолчанию.

Аргумент view_func передавать необязательно, но если правило должно участвовать в маршрутизации, то имя конечной точки должно быть связано с функцией-представлением в какой-то момент с помощью декоратора @Flask.endpoint().

app.add_url_rule("/", endpoint="index")

@app.endpoint("index")
def index():
    ...

Если функция view_func имеет атрибут required_methods, то эти методы добавляются к переданным и автоматическим методам. Если view_func имеет атрибут provide_automatic_options, то его значение будет использоваться по умолчанию, если одноименный аргумент не передан.

Описание аргументов:

  • rule: правило URL-адреса в виде строки;
  • endpoint: конечная точка для зарегистрированного правила URL-адреса. Сам Flask предполагает, что имя функции-представления является именем конечной точки, если явно она не задана;
  • view_func: функция, вызываемая при обслуживании запроса к предоставленной конечной точке. Если аргумент не передан, то можно указать функцию позже, сохранив ее в словаре Flask.view_functions с конечной точкой в качестве ключа.
  • provide_automatic_options: если функция-представление определяет этот атрибут как True, то Flask принудительно включит автоматическую реализацию ответа HTTP OPTIONS.
  • **options: – дополнительные параметры, для объекта Rule().

Flask.after_request(f):

Метод Flask.after_request() регистрирует функцию f, которая будет запускаться после каждого запроса к этому объекту. Используется в качестве декоратора.

Переданная в качестве аргумента функция f вызывается с объектом ответа и должна возвращать объект ответа Response. Такое поведение позволяет функциям f изменять или заменять ответ перед его отправкой клиенту.

Если переданная функция f вызывает исключение, то все оставшиеся функции after_request вызываться не будут. Следовательно, метод не следует использовать для действий, которые обязательны к выполнению, например, закрытие задействованных ресурсов. Для этого необходимо использовать декоратор @Flask.teardown_request().

Flask.after_request_funcs:

Атрибут Flask.after_request_funcs содержит структуру данных функций, вызываемых в конце каждого запроса, в формате {scope: [functions]}. Ключ scope - это имя схемы blueprint, для которой активны функции, или None для всех запросов.

Для регистрации функции, необходимо использовать декоратор Flask.after_request().

Эта структура данных внутренняя. Её нельзя изменять напрямую, и её формат может измениться в любое время.

Flask.app_context():

Метод Flask.app_context() создает контекст приложения AppContext. Для проталкивания контекста, который будет указывать на на это приложение current_app, нужно использовать как блок with .

Контекст приложения автоматически передается RequestContext.push() при обработке запроса и при выполнении команды CLI.

Создание контекста приложения вручную:

with app.app_context():
    init_db()

Flask.app_ctx_globals_class:

Атрибут Flask.app_ctx_globals_class - это ссылка на flask.ctx._AppCtxGlobals. Дополнительно смотрите описание объекта flask.g.

Flask.async_to_sync(func):

Метод Flask.async_to_sync() возвращает функцию синхронизации, которая будет запускать функцию сопрограммы.

result = app.async_to_sync(func)(*args, **kwargs)

Для изменения способа преобразования асинхронного кода приложением для синхронного вызова необходимо переопределить этот метод.

Новое в версии 2.0.

Flask.auto_find_instance_path():

Метод Flask.auto_find_instance_path() пытается найти путь к экземпляру, если он не был предоставлен конструктору класса приложения. По сути, он вычислит путь к папке с именем instance рядом с основным файлом приложения или пакетом.

Flask.before_first_request(f):

Метод Flask.before_first_request() регистрирует функцию f, которая будет запускаться перед первым запросом к этому экземпляру приложения. Используется в качестве декоратора

Переданная функция f будет вызываться без аргументов, а ее возвращаемое значение игнорируется.

Flask.before_first_request_funcs:

Атрибут Flask.before_first_request_funcs содержит список функций, которые будут вызываться в начале первого запроса к этому экземпляру. Чтобы зарегистрировать функцию, необходимо использовать декоратор @Flask.before_first_request().

Flask.before_request(f):

Метод Flask.before_request() регистрирует функцию f, которая будет запускаться перед каждым запросом. Используется в качестве декоратора

Например, этот метод можно использовать для открытия соединения с базой данных или для загрузки вошедшего в систему пользователя из сеанса.

@app.before_request
def load_user():
    if "user_id" in session:
        g.user = db.session.get(session["user_id"])

Переданная функция f будет вызываться без каких-либо аргументов. Если она возвращает значение, отличное от None, то возвращаемое значение обрабатывается так, как если бы оно было возвращаемым значением из функции-представления, и дальнейшая обработка запроса прекращается.

Flask.before_request_funcs:

Атрибут Flask.before_request_funcs содержит структуру данных функций, вызываемых в начале каждого запроса, в формате {scope: [functions]}. Ключ scope - это имя схемы blueprint, для которой активны функции, или None для всех запросов.

Для регистрации функции, необходимо использовать декоратор Flask.before_request().

Эта структура данных внутренняя. Её нельзя изменять напрямую, и её формат может измениться в любое время.

Flask.blueprints:

Атрибут Flask.blueprints содержит словарь с именами зарегистрированных схем в качестве ключей и объектами Blueprint в качестве значений.

Этот словарь сохраняет порядок, в котором были зарегистрированы схемы blueprint. Схемы можно регистрировать несколько раз, словарь не отслеживает, как часто они регистрировались.

Flask.cli:

Атрибут Flask.cli содержит группу команд модуля click, предназначенных для регистрации команд интерфейса командной строки. Команды доступны из команды flask после того, как приложение было обнаружено, а схемы blueprint были зарегистрированы.

Flask.config:

Атрибут Flask.config содержит словарь конфигурации Config. Он ведет себя точно так же, как обычный словарь, но поддерживает дополнительные методы для загрузки конфигурации из файлов.

Flask.config_class:

Атрибут Flask.config_class ссылка на реализацию класса конфигурации flask.config.Config.

Flask.context_processor(f):

Метод Flask.context_processor() регистрирует функцию f обработчика контекста шаблона.

Flask.create_global_jinja_loader():

Метод Flask.create_global_jinja_loader() создает загрузчик для среды шаблонизатора Jinja2. Не рекомендуется переопределять этот метод. Вместо этого следует переопределить метод Flask.jinja_loader().

Глобальный загрузчик осуществляет обмен между загрузчиками приложения и отдельными схемами элементов.

Flask.create_jinja_environment():

Метод Flask.create_jinja_environment() создает среду Jinja2 на основе Flask.jinja_options и различных связанных с Jinja методов приложения. Изменение Flask.jinja_options после создания экземпляра приложения ни на что не повлияет. Также добавляет в среду глобальные объекты и фильтры, связанные с Flask.

Flask.create_url_adapter(request):

Метод Flask.create_url_adapter() создает адаптер URL для данного запроса. Адаптер URL-адреса создается в точке, где контекст запроса еще не настроен, поэтому запрос передается явно.

Flask.debug:

Свойство Flask.debug содержит bool значение режима отладки. При использовании метода Flask.run() для запуска сервера разработки, для необработанных исключений будет показан интерактивный отладчик, а сервер будет перезагружен при каждом изменении кода приложения.

Значение соответствует конфигурационному ключу DEBUG. Свойство Flask.debug будет равным True, когда env имеет значение 'development' и переопределяется переменной среды FLASK_DEBUG. Если задано в коде, он может вести себя не так, как ожидалось.

Существует три способа включить отладку:

# через атрибут экземпляра приложения 
app.debug = True
app.run()

# через аргумент метода `.run()`
app.run(debug=True)

Через FLASK_ENV (Если используется Flask 1.1 и выше)

$ export FLASK_ENV=development
$ flask run

Не включайте режим отладки при развертывании на "боевом" сервере.

Flask.default_config:

Атрибут Flask.default_config содержит словарь с параметрами конфигурации по умолчанию.

>>> app.default_config
# { 
# 'APPLICATION_ROOT': '/', 'DEBUG': None, 'ENV': None, 
# 'EXPLAIN_TEMPLATE_LOADING': False, 'JSONIFY_MIMETYPE': 'application/json', 
# 'JSONIFY_PRETTYPRINT_REGULAR': False, 'JSON_AS_ASCII': True, 
# 'JSON_SORT_KEYS': True, 'MAX_CONTENT_LENGTH': None, 
# 'MAX_COOKIE_SIZE': 4093, 'PERMANENT_SESSION_LIFETIME': datetime.timedelta(days=31), 
# 'PREFERRED_URL_SCHEME': 'http', 'PRESERVE_CONTEXT_ON_EXCEPTION': None, 
# 'PROPAGATE_EXCEPTIONS': None, 'SECRET_KEY': None, 
# 'SEND_FILE_MAX_AGE_DEFAULT': None, 'SERVER_NAME': None, 
# 'SESSION_COOKIE_DOMAIN': None, 'SESSION_COOKIE_HTTPONLY': True, 
# 'SESSION_COOKIE_NAME': 'session', 'SESSION_COOKIE_PATH': None, 
# 'SESSION_COOKIE_SAMESITE': None, 'SESSION_COOKIE_SECURE': False, 
# 'SESSION_REFRESH_EACH_REQUEST': True, 'TEMPLATES_AUTO_RELOAD': None, 
# 'TESTING': False, 'TRAP_BAD_REQUEST_ERRORS': None, 
# 'TRAP_HTTP_EXCEPTIONS': False, 'USE_X_SENDFILE': False
# }

Flask.delete(rule, **options):

Декоратор Flask.delete() - это ссылка на декоратор Flask.route() с переданным аргументом methods=["DELETE"].

Новое в версии 2.0.

Flask.dispatch_request():

Метод Flask.dispatch_request() осуществляет отправку запроса. Соответствует URL-адресу и возвращает значение функции-представления или обработчика ошибок.

Это не обязательно должен быть объект ответа Response. Чтобы преобразовать возвращаемое значение в правильный объект ответа, необходимо вызвать функцию flask.make_response().

Flask.do_teardown_appcontext(exc=<object object>):

Метод Flask.do_teardown_appcontext() вызывается прямо перед появлением контекста приложения.

При обработке запроса, контекст приложения появляется после контекста запроса. Дополнительно смотрите метод Flask.do_teardown_request().

Этот метод вызывает все функции, оформленные с помощью декоратора Flask.teardown_appcontext(). Затем отправляется сигнал flask.appcontext_tearing_down.

Flask.do_teardown_request(exc=<object object>):

Метод Flask.do_teardown_request() вызывается после отправки запроса и возврата ответа, прямо перед открытием контекста запроса.

Этот метод вызывает все функции, оформленные с помощью декоратора Flask.teardown_request() и Blueprint.teardown_request(), если проект обработал запрос. Наконец, отправляется сигнал [flask.request_tearing_down][].

Flask.do_teardown_request() вызывается RequestContext.pop(), который может быть отложен во время тестирования для сохранения доступа к ресурсам.

Аргумент exc - это необработанное исключение, возникшее при отправке запроса и если не передается, то обнаруживается из текущей информации об исключении. Передается каждой функции teardown.

Flask.endpoint(endpoint):

Декоратор Flask.endpoint() располагается вверху функции-представления, которая регистрируется для данной конечной точки endpoint.

Используется, если URL правило добавляется с помощью метода Flask.add_url_rule() и без указания функции view_func .

Аргумент endpoint - это строка с именем конечной точки, связываемое с функцией-представления.

app.add_url_rule("/ex", endpoint="example")

@app.endpoint("example")
def example():
    ...

Flask.ensure_sync(func):

Метод Flask.ensure_sync() проверяет, что функция func синхронна для воркера WSGI. Простые функции, определяемые при помощи def возвращаются как есть. Функции, определяемые при помощи async def оборачиваются для запуска и ожидания ответа.

Переопределите этот метод, чтобы изменить способ запуска асинхронных представлений приложением Flask.

Новое в версии 2.0.

Flask.env:

Атрибут Flask.env содержит среду выполнения приложения. Значение по умолчанию 'production'.

Фреймворк Flask и его расширения могут вести себя по разному в зависимости от значения среды env, например, включать режима отладки.

Атрибут Flask.env соответствует ключу конфигурации ENV. Так же устанавливается переменной среды FLASK_ENV и может вести себя не так, как ожидалось, если значение установлено в коде приложения.

$ export FLASK_ENV=development
$ flask run

Не включайте режим разработки 'development' при развертывании на "боевом" сервере.

Flask.error_handler_spec:

Атрибут Flask.error_handler_spec содержит структуру данных зарегистрированных обработчиков ошибок в формате {scope: {code: {class: handler}}}.

Ключ области scope - это имя схемы blueprint, для которой активны обработчики, или None для всех запросов. Ключ code - это код состояния HTTP для HTTPException или None для других исключений. Самый внутренний словарь сопоставляет классы исключений с функциями-обработчиками.

Чтобы зарегистрировать обработчик ошибок, используйте декоратор Flask.errorhandler().

Это внутренняя структура данных. Ее нельзя изменять напрямую, и ее формат может измениться в любое время.

Flask.errorhandler(code_or_exception):

Декоратор Flask.errorhandler() регистрирует функцию для обработки ошибок по коду или классу исключения. Используется для регистрации функции с кодом ошибки.

Например:

@app.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404

You can also register handlers for arbitrary exceptions:

@app.errorhandler(DatabaseError)
def special_exception_handler(error):
    return 'Database connection failed', 500

Аргумент code_or_exception - это код как целое число для обработчика или произвольный класс исключения.

Flask.extensions:

Flask.extensions это словарь, где расширения могут сохранять состояние, специфичное для приложения. Например, здесь расширение может хранить движки баз данных и тому подобное.

Ключ словаря должен совпадать с названием модуля расширения. Например, в случае расширения Flask-Foo в flask_foo ключом будет foo.

Flask.full_dispatch_request():

Метод Flask.full_dispatch_request() отправляет запрос и, кроме того, выполняет предварительную и постобработку запроса, а также перехват исключений HTTP и обработку ошибок.

Flask.get(rule, **options):

Метод Flask.get() представляет собой ссылку на Flask.route() с заранее переданным аргументом methods=["GET"].

Новое в версии 2.0.

Flask.get_send_file_max_age(filename):

Метод Flask.get_send_file_max_age() используется функцией flask.send_file() для определения значения кеша max_age для заданного пути к файлу, если оно не было передано.

По умолчанию метод возвращает SEND_FILE_MAX_AGE_DEFAULT из конфигурации, возвращаемой flask.current_app. По умолчанию это значение None, что указывает браузеру использовать условные запросы вместо кэширования по времени, что обычно предпочтительнее.

Изменено в версии 2.0: Конфигурация по умолчанию - None вместо 12 часов.

Flask.property got_first_request: bool:

Атрибут Flask.property имеет значение True, если приложение Flask начало обрабатывать первый запрос.

Flask.handle_exception(e):

Метод Flask.handle_exception() обрабатывает исключения e, с которым не связан обработчик ошибок, или которое было вызвано обработчиком ошибок. Метод всегда вызывает ошибку 500 InternalServerError.

Всегда отправляет сигнал flask.got_request_exception().

Если атрибут Flask.propagate_exceptions имеет значение True, например, в режиме отладки, то ошибка будет повторно вызвана, чтобы отладчик мог ее отобразить. В противном случае регистрируется исходное исключение и возвращается InternalServerError.

Если обработчик ошибок зарегистрирован для InternalServerError или 500, то он будет использован. Для согласованности обработчик всегда будет получать InternalServerError. Исходное необработанное исключение доступно как e.original_exception.

Flask.handle_http_exception(e):

Метод Flask.handle_http_exception() обрабатывает HTTP-исключение. По умолчанию метод вызовет зарегистрированные обработчики ошибок и вернет исключение в качестве ответа.

Flask.handle_url_build_error(error, endpoint, values):

Метод Flask.handle_url_build_error() обрабатывает ошибки BuildError в функции flask.url_for().

Flask.handle_user_exception(e):

Метод Flask.handle_user_exception() вызывается всякий раз, когда возникает исключение, которое необходимо обработать. Особым случаем является исключение HTTPException, которое перенаправляется методу Flask.handle_http_exception().

Метод Flask.handle_user_exception() либо вернет значение ответа, либо повторно вызовет исключение с той же трассировкой.

Flask.has_static_folder: bool:

Свойство Flask.has_static_folder имеет значение True, если установлена ​​Flask.static_folder.

Flask.import_name:

Атрибут Flask.import_name содержит имя пакета или модуля, которому принадлежит этот объект. Не изменяйте это значение, если оно установлено в конструкторе класса flask.Flask().

Flask.inject_url_defaults(endpoint, values):

Метод Flask.inject_url_defaults() внедряет URL-адреса по умолчанию для данной конечной точки endpoint непосредственно в переданный словарь значений. Метод используется внутри Flask и автоматически вызывается при построении URL.

Flask.instance_path:

Атрибут Flask.instance_path содержит путь к папке экземпляра.

Flask.iter_blueprints():

Метод Flask.iter_blueprints() содержит итератор всех схем blueprint приложения в том порядке, в котором они были зарегистрированы..

Flask.jinja_env:

Свойство Flask.jinja_env содержит среду Jinja, которая используется для загрузки шаблонов.

Среда Jinja создается при первом обращении к этому свойству, изменение Flask.jinja_env после этого ни на что не повлияет.

Flask.jinja_environment:

Атрибут Flask.jinja_environment представляет собой ссылку на flask.templating.Environment.

Flask.jinja_loader:

Свойство Flask.jinja_loader содержит загрузчик Jinja для шаблонов этого объекта. По умолчанию это класс jinja2.loaders.FileSystemLoader для Flask.template_folder, если он установлен.

Flask.jinja_options:

Атрибут Flask.jinja_options содержит словарь с аргументами, которые передаются в среду Jinja в Flask.create_jinja_environment(). Изменение этих параметров после создания среды (доступ к jinja_env) не будет иметь никакого эффекта.

Flask.json_decoder:

Атрибут Flask.json_decoder представляет собой ссылку на класс flask.json.JSONDecoder.

Flask.json_encoder:

Атрибут Flask.json_encoder представляет собой ссылку на класс flask.json.JSONEncoder.

Flask.log_exception(exc_info):

Метод Flask.log_exception() регистрирует исключение exc_info. Метод вызывается Flask.handle_exception(), прямо перед вызовом обработчика, если отладка отключена. Реализация по умолчанию регистрирует исключение как ошибку в регистраторе.

Flask.logger:

Свойство Flask.logger содержит стандартный класс Python logging.Logger для приложения с тем же именем, что и имя приложения. В режиме отладки уровень регистратора будет установлен на DEBUG.

Если обработчики не настроены, то будет добавлен обработчик по умолчанию. Дополнительно смотрите раздел "Ведение журнала логов в приложении Flask".

Flask.make_config(instance_relative=False):

Метод Flask.make_config() используется конструктором Flask для создания атрибута Flask.config.

Аргумент instance_relative передается из конструктора Flask (он называется instance_relative_config) и указывает, должна ли конфигурация относиться к пути экземпляра или корневому пути приложения.

Flask.make_default_options_response():

Метод Flask.make_default_options_response() вызывается для создания ответа OPTIONS по умолчанию. Поведение ответов OPTIONS по умолчанию можно изменить путем создания подклассов.

Flask.make_response(rv):

Метод Flask.make_response() преобразует возвращаемое значение из функции-представления в экземпляр Flask.response_class.

Аргумент rv - это возвращаемое значение из функции-представления. Функция-представление должна возвращать ответ. Возвращаемое значение None или завершение просмотра без возвращаемого значения недопустимы. Для view_rv разрешены следующие типы:

  • str: объект ответа создается со строкой, закодированной в UTF-8 в качестве тела.
  • bytes: объект ответа создается с байтовой строкой в качестве тела.
  • dict: словарь, который будет преобразован JSON перед возвратом.
  • tuple: (body, status, headers), (body, status), или (body, headers), где body - любой из других разрешенных здесь типов, status - строка или целое число, а headers - словарь или список кортежей (key, value). Если тело body является экземпляром класса Flask.response_class, то статус status перезаписывает исходящее значение, и заголовки headers расширяются.

Flask.make_shell_context():

Метод Flask.make_shell_context() возвращает контекст для интерактивной оболочки для этого приложения. Метод запускает все зарегистрированные процессоры контекста оболочки.

Flask.name:

Свойство Flask.name содержит название приложения, его можно устанавливать и переопределять. Обычно это значение совпадает со значением аргумента конструктора import_name, с той лишь разницей, что оно берется из запускаемого файла.

Это имя используется в качестве отображаемого имени приложения Flask.

Flask.open_instance_resource(resource, mode='rb'):

Метод Flask.open_instance_resource() открывает ресурс из папки экземпляра приложения Flask.instance_path. В остальном работает как Flask.open_resource. Ресурсы экземпляра также могут быть открыты для записи.

Аргументы:

  • resource: строка с именем ресурса. Для доступа к ресурсам внутри вложенных папок используйте косые черты в качестве разделителя.
  • mode: режим открытия файла ресурсов, по умолчанию 'rb'.

Flask.open_resource(resource, mode='rb'):

Метод Flask.open_resource() открывает файл ресурсов относительно Flask.root_path для чтения.

Например, если файл schema.sql находится рядом с файлом app.py там, где определено приложение Flask, его можно открыть с помощью:

with app.open_resource("schema.sql") as f:
    conn.executescript(f.read())

Аргументы:

  • resource: путь к ресурсу относительно Flask.root_path.
  • mode: режим открытия файла ресурсов. Поддерживается только чтение, допустимые значения - 'r' и 'rb'.

Flask.patch(rule, **options):

Метод Flask.patch() представляет собой ссылку на Flask.route() с заранее переданным аргументом methods=["PATCH"].

Новое в версии 2.0.

Flask.permanent_session_lifetime:

Атрибут Flask.permanent_session_lifetime содержит datetime.timedelta, который используется для установки даты истечения срока постоянного сеанса. Значение по умолчанию - 31 день, поэтому постоянный сеанс просуществует примерно один месяц.

Этот атрибут также можно настроить из конфигурации с помощью ключа PERMANENT_SESSION_LIFETIME. По умолчанию datetime.timedelta(days=31).

Flask.post(rule, **options):

Метод Flask.post() представляет собой ссылку на Flask.route() с заранее переданным аргументом methods=["POST"].

Новое в версии 2.0.

Flask.preprocess_request():

Метод Flask.preprocess_request() вызывается перед отправкой запроса. Вызывает Flask.url_value_preprocessors, зарегистрированные в приложении, и текущую схему blueprint (если есть). Затем вызывает Flask.before_request_funcs, зарегистрированный в приложении и схеме.

Если какой-либо обработчик Flask.before_request() возвращает значение, отличное от None, то значение обрабатывается так, как если бы оно было возвращаемым значением из функции-представления, и дальнейшая обработка запроса прекращается.

Flask.preserve_context_on_exception:

Свойство Flask.preserve_context_on_exception возвращает значение параметра конфигурации PRESERVE_CONTEXT_ON_EXCEPTION, если оно установлено, в противном случае возвращается разумное значение по умолчанию.

Flask.process_response(response):

Метод Flask.process_response() может быть переопределен для изменения объекта ответа перед его отправкой на сервер WSGI. По умолчанию, этот метод вызовет все функции, декорированные @Flask.after_request().

Аргумент response это объект Flask.response_class.

Возвращает новый объект ответа или тот же, должен быть экземпляром Flask.response_class.

Flask.propagate_exceptions: bool:

Свойство Flask.propagate_exceptions возвращает значение параметра конфигурации PROPAGATE_EXCEPTIONS, если оно установлено, в противном случае возвращается разумное значение по умолчанию.

Flask.put(rule, **options):

Метод Flask.put() представляет собой ссылку на Flask.route() с заранее переданным аргументом methods=["PUT"].

Новое в версии 2.0.

Flask.register_blueprint(blueprint, **options):

Метод Flask.register_blueprint() регистрирует схему Blueprint в приложении Flask. Ключевые аргументы, переданные этому методу, переопределят значения по умолчанию, установленные в схеме blueprint.

Вызывает метод схемы Blueprint.register() после записи схемы элементов в схемы элементов приложения.

  • blueprint: объектBlueprint` для регистрации.
  • url_prefix: префикс, используемый URL-маршрутами схемы.
  • subdomain: поддомен, на котором будут работать маршруты схемы.
  • url_defaults: значения по умолчанию для маршрутов blueprint для аргументов представления.
  • **options: дополнительные ключевые аргументы, передаются в BlueprintSetupState. Доступ к ним можно получить в обратных вызовах Blueprint.record().

Flask.register_error_handler(code_or_exception, f):

Альтернативный метод Flask.register_error_handler() присоединения ошибки к декоратору @Flask.errorhandler(), более простая для использования.

Flask.request_class:

Атрибут Flask.request_class представляет собой ссылку на flask.wrappers.Request.

Flask.request_context(environ):

Метод Flask.request_context() создает RequestContext, представляющий среду WSGI environ. Используется с блоком with, чтобы протолкнуть контекст, что позволит указать flask.request на этот запрос.

Дополнительно смотрите раздел "Контекст запроса"

Не надо вызывать этот метод из собственного кода. Контекст запроса автоматически передается Flask.wsgi_app() при обработке запроса. Для создания среды и контекста, вместо этого метода, используйте Flask.test_request_context().

Flask.response_class:

Атрибут Flask.response_class представляет собой ссылку на flask.wrappers.Response.

Flask.root_path:

Атрибут Flask.root_path содержит абсолютный путь к пакету в файловой системе. Используется для поиска ресурсов, содержащихся в пакете.

Flask.route(rule, **options):

Декоратор Flask.route() располагается сверху функций-представлений, тем самым регистрируя ее с заданным правилом rule и параметрами URL-адреса. Вызывает метод Flask.add_url_rule(), который имеет более подробную информацию о реализации.

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

Смотрите раздел "Декоратор @route() и метод add_url_rule() приложения Flask".

Если аргумент endpoint не передан, то в качестве его имени для маршрута по умолчанию используется имя функции-представления.

По умолчанию, для аргумента methods установлено значение ['GET']. HTTP-методы HEAD и OPTIONS добавляются автоматически.

Flask.run(host=None, port=None, debug=None, load_dotenv=True, **options):

Метод Flask.run() запускает приложение на локальном сервере разработки.

Не используйте Flask.run() на "боевом" сервере. Метод не предназначен для обеспечения безопасности и производительности рабочего сервера.

Если аргумент debug=True, то сервер автоматически будет перезагружаться при каждом изменений кода и покажет отладчик в случае возникновения исключения.

Если необходимо запустить приложение в режиме отладки, но отключить выполнение кода в интерактивном отладчике, то можно передать use_evalex=False. Это сохранит экран трассировки отладчика активным, но отключит выполнение кода.

Не рекомендуется использовать этот метод для разработки с автоматической перезагрузкой, так как она плохо поддерживается. Вместо этого вам следует использовать поддержку запуска сценария командной строки flask.

Иметь ввидуFlask подавит любую ошибку сервера с помощью общей страницы ошибок, если он не находится в режиме отладки. Таким образом, чтобы включить только интерактивный отладчик без перезагрузки кода, вы должны вызвать run () с debug = True и usereloader = False. Установка usedebugger в True без перехода в режим отладки не приведет к обнаружению исключений, потому что их не будет.

Описание аргументов:

  • host: строка с именем хоста для прослушивания. Установите значение '0.0.0.0', чтобы сервер также был доступен извне. По умолчанию '127.0.0.1' или хост, определенный в переменной конфигурации SERVER_NAME.
  • port: порт веб-сервера. По умолчанию используется значение 5000 или порт, определенный в переменной конфигурации SERVER_NAME.
  • debug: включает или отключает режим отладки.
  • load_dotenv: установить переменные среды, загружая ближайшие файлы .env и .flaskenv. Также изменит рабочий каталог на каталог, содержащий первый найденный файл.
  • **options: параметры, которые будут перенаправлены на базовый сервер Werkzeug.

Flask.secret_key:

Атрибут Flask.secret_key содержит секретный ключ, используется для подписи файлов cookie и других вещей. Необходимо установить сложное случайное значение. По умолчанию None.

Этот атрибут также можно настроить из конфигурации с помощью ключа конфигурации SECRET_KEY.

Flask.select_jinja_autoescape(filename):

Метод Flask.select_jinja_autoescape() возвращает True, если автоматическое экранирование HTML активно для данного имени шаблона filename. Если имя шаблона не указано, то возвращает True.

Flask.send_file_max_age_default:

Атрибут Flask.send_file_max_age_default содержит datetime.timedelta или количество секунд, которое используется как max_age по умолчанию для flask.send_file(). По умолчанию установлено значение None, что указывает браузеру использовать условные запросы вместо временного кеша.

Настраивается с помощью ключа конфигурации SEND_FILE_MAX_AGE_DEFAULT.

Изменено в версии 2.0: по умолчанию установлено значение None вместо 12 часов.

Flask.send_static_file(filename):

Метод Flask.send_static_file() представляет собой функцию-представление, которая используется для обслуживания файлов из Flask.static_folder.

Для этого представления, в Flask.static_url_path, автоматически регистрируется маршрут, при условии, что установлена ​​Flask.static_folder.

Flask.session_cookie_name:

Атрибут Flask.session_cookie_name содержит строку с именем для безопасного файла cookie, используемого в сессии/сеансе. По умолчанию имеет значение 'session'.

Этот атрибут также можно настроить из конфигурации с помощью ключа SESSION_COOKIE_NAME.

Flask.session_interface:

Атрибут Flask.session_interface содержит используемый интерфейс сессии/сеансе. По умолчанию используется экземпляр flask.sessions.SecureCookieSessionInterface.

Flask.shell_context_processors:

Атрибут Flask.shell_context_processors содержит список функций процессора, которые должны запускаться при создании контекста оболочки.

Flask.should_ignore_error(error):

Метод Flask.should_ignore_error() выясняет, следует ли игнорировать ошибку error или нет, если речь идет о системе освобождения ресурсов teardown. Если метод возвращает значение True, то обработчикам teardown не будет передана ошибка.

Flask.static_folder:

Свойство Flask.static_folder содержит абсолютный путь к настроенной статической папке. None, если статическая папка не задана.

Flask.static_url_path:

Свойство Flask.static_url_path содержит префикс URL-адреса, с которого будет доступен статический маршрут.

Если свойство не было настроено во время инициализации, то он является производным от Flask.static_folder.

Flask.teardown_appcontext(f):

Декоратор Flask.teardown_appcontext() регистрирует функцию f, которая будет вызываться при завершении контекста приложения. Эти функции обычно также вызываются при открытии контекста запроса.

Пример:

ctx = app.app_context()
ctx.push()
...
ctx.pop()

Когда выполняется ctx.pop(), функции f вызываются непосредственно перед перемещением контекста приложения из стека активных контекстов. Такое поведение становится актуальным, если такие конструкции используются в тестах.

Если функция f была вызвана из-за необработанного исключения, то ей будет передан объект ошибки. И если зарегистрирован Flask.errorhandler(), то он обработает исключение, а функция f не получит его.

Возвращаемые значения функций teardown игнорируются.

Flask.teardown_appcontext_funcs:

Атрибут Flask.teardown_appcontext_funcs содержит список функций, вызываемых при уничтожении контекста приложения.

Так как при завершении запроса контекст приложения также уничтожается, то это хорошее место для хранения кода, который закрывает соединение с базой данных.

Flask.teardown_request(f):

Декоратор Flask.teardown_request() регистрирует функцию f, которая будет запускаться в конце каждого запроса, независимо от того, было ли вызвано исключение в коде или нет. Эти функции выполняются при открытии контекста запроса, даже если фактический запрос не был выполнен.

Пример:

ctx = app.test_request_context()
ctx.push()
...
ctx.pop()

Когда выполняется ctx.pop(), функции teardown вызываются непосредственно перед перемещением контекста запроса из стека активных контекстов. Такое поведение становится актуальным, если такие конструкции используются в тестах.

Функции f не должны вызывать исключения. Если они выполняют код, который может дать сбой, то его необходимо заключить в конструкцию try/except и регистрировать возникающие ошибки.

Если функция f была вызвана из-за исключения, ей будет передан объект ошибки.

Возвращаемые значения функций f игнорируются.

Примечание: В режиме отладки Flask не будет немедленно отменять запрос на исключение. Flask сохранит его в рабочем состоянии, чтобы интерактивный отладчик мог получить к нему доступ. Этим поведением можно управлять с помощью переменной конфигурации PRESERVE_CONTEXT_ON_EXCEPTION.

Flask.teardown_request_funcs:

Атрибут Flask.teardown_request_funcs содержит структуру данных функций, вызываемых в конце каждого запроса, даже если возникает исключение, в формате {scope: [functions]}. Ключ scope - это имя схемы blueprint, для которой активны функции, или None для всех запросов.

Чтобы зарегистрировать функцию, необходимо использовать декоратор Flask.teardown_request().

Это структура данных внутренняя. Ее нельзя изменять напрямую, и ее формат может измениться в любое время.

Flask.template_context_processors:

Атрибут Flask.template_context_processors содержит структуру данных функций, вызываемых для передачи дополнительных значений контекста при отрисовке шаблонов, в формате {scope: [functions]}. Ключ scope - это имя схемы blueprint, для которой активны функции, или None для всех запросов.

Чтобы зарегистрировать функцию, используйте декоратор Flask.context_processor().

Это внутренняя структура данных. Ее нельзя изменять напрямую, и ее формат может измениться в любое время.

Flask.template_filter(name=None):

Декоратор @Flask.template_filter() используется для регистрации пользовательского фильтра name для использования в шаблоне.

Аргумент name представляет собой имя для фильтра, по которому он будет доступен в шаблоне, иначе будет использовано имя функции.

@app.template_filter()
def reverse(s):
    return s[::-1]

Flask.template_folder:

Атрибут Flask.template_folder содержит путь к папке шаблонов относительно Flask.root_path. None, если не нужно добавлять шаблоны.

Flask.template_global(name=None):

Декоратор @Flask.template_global() используется для регистрации глобальной функции для шаблона.

Аргумент name представляет собой имя, по которому будет доступна эта глобальная функция в шаблоне, в противном случае будет использовано имя глобальной функции.

@app.template_global()
def double(n):
    return 2 * n

Flask.template_test(name=None):

Декоратор @Flask.template_test() используется для регистрации пользовательского теста для шаблона.

Аргумент name представляет собой имя, по которому будет доступен этот тест, иначе будет использовано имя функции.

@app.template_test()
def is_prime(n):
    if n == 2:
        return True
    for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
        if n % i == 0:
            return False
    return True

Flask.templates_auto_reload: bool:

Свойство Flask.templates_auto_reload обновляет шаблоны, как только они будут изменены. Используется Flask.create_jinja_environment().

Этот атрибут можно настроить с помощью TEMPLATES_AUTO_RELOAD, в режиме отладки он включается автоматически.

Flask.test_cli_runner(**kwargs):

Метод Flask.test_cli_runner() создает средство выполнения для тестирования команд CLI

Возвращает экземпляр Flask.test_cli_runner_class, по умолчанию FlaskCliRunner. В качестве первого аргумента передается объект приложения Flask.

Flask.test_cli_runner_class:

Атрибут Flask.test_cli_runner_class содержит подкласс CliRunner, по умолчанию FlaskCliRunner, который используется методом Flask.test_cli_runner. Его метод __init__ должен принимать объект приложения Flask в качестве первого аргумента.

Flask.test_client(use_cookies=True, **kwargs):

Метод Flask.test_client() создает тестового клиента для этого приложения.

Обратите внимание: если тестируете утверждения или исключения в коде приложения, то необходимо установить app.testing=True, чтобы исключения распространялись на тестовый клиент. В противном случае исключение будет обрабатываться приложением (не видимым для тестового клиента), и единственным признаком AssertionError или другого исключения будет ответ с кодом состояния 500 для тестового клиента. Дополнительно смотрите атрибут Flask.testing

Например:

app.testing = True
client = app.test_client()

Тестовый клиент может использоваться в блоке with, чтобы отложить закрытие контекста до конца блока with. Это поведение полезно, если надо получить доступ к локальным контекстам для тестирования:

with app.test_client() as c:
    rv = c.get('/?vodka=42')
    assert request.args['vodka'] == '42'

Кроме того, можно передать необязательные ключевые аргументы, которые затем будут переданы конструктору приложения Flask.test_client_class. Например:

from flask.testing import FlaskClient

class CustomClient(FlaskClient):
    def __init__(self, *args, **kwargs):
        self._authentication = kwargs.pop("authentication")
        super(CustomClient,self).__init__( *args, **kwargs)

app.test_client_class = CustomClient
client = app.test_client(authentication='Basic ....')

Flask.test_client_class:

Атрибут Flask.test_client_class тестовый клиент, который использует Flask.test_client.

Flask.test_request_context(*args, **kwargs):

Метод Flask.test_request_context() создает RequestContext для среды WSGI, созданной из заданных значений. Метод в основном полезен во время тестирования, когда нужно запустить функцию, которая использует данные запроса, не отправляя полный запрос.

Дополнительно смотрите раздел "Контекст запроса".

Нужно используйте блок with, чтобы протолкнуть контекст, который укажет на запрос для созданной среды,

with test_request_context(...):
    generate_report()

При использовании интерпретатора может быть проще проталкивать и извлекать контекст вручную.

ctx = app.test_request_context(...)
ctx.push()
...
ctx.pop()

Принимает те же аргументы, что и EnvironBuilder модуля Werkzeug, с некоторыми значениями по умолчанию из приложения. Здесь разобрано поведение, специфичное для Flask.

Принимаемые аргументы:

  • path: запрашиваемый URL-путь.
  • base_url: базовый URL-адрес, по которому обслуживается приложение, относительно которого указан path. Если не указан, то создается из PREFERRED_URL_SCHEME, subdomain, SERVER_NAME и APPLICATION_ROOT.
  • subdomain: имя субдомена, используемое вместо SERVER_NAME.
  • url_scheme: Схема, используемая вместо PREFERRED_URL_SCHEME.
  • data: тело запроса в виде строки или словаря ключей и значений формы.
  • json: если задан, то он сериализуется как JSON и передается как данные data. Также по умолчанию content_type равно application/json.
  • args: другие позиционные аргументы EnvironBuilder.
  • kwargs: другие ключевые аргументы EnvironBuilder.

Flask.testing:

Атрибут Flask.testing содержит значение флага тестирования. Чтобы включить режим тестирования расширений Flask (а в будущем, вероятно, и самого Flask), необходимо установите для этого атрибута значение True. По умолчанию False.

Например, это может активировать помощников по тестированию, которые требуют дополнительных затрат времени выполнения, и соответственно отключены по умолчанию.

Этот атрибут также можно настроить из конфигурации с помощью ключа TESTING.

Flask.trap_http_exception(e):

Метод Flask.trap_http_exception() проверяет, следует ли перехватить исключение HTTP. По умолчанию, метод вернет False для всех исключений, кроме ошибки неверного ключа запроса, если TRAP_BAD_REQUEST_ERRORS установлен в True. Он также возвращает True, если TRAP_HTTP_EXCEPTIONS установлен в True.

Метод вызывается для всех HTTP-исключений, вызванных функцией-представлением. Если он возвращает True для любого исключения, то обработчик ошибок для этого исключения не вызывается и отображается как обычное исключение в трассировке. Такое поведение полезно для отладки неявно вызванных HTTP-исключений.

Flask.update_template_context(context):

Метод Flask.update_template_context() обновляет контекст шаблона, добавив некоторые часто используемые переменные context.

Метод вводит request, session, config и g в контекст шаблона, а также все, что внедряют процессоры контекста шаблона. Обратите внимание, что, начиная с Flask 0.6, исходные значения в контексте не будут переопределены, если обработчик контекста будет возвращать значение с тем же ключом.

Аргумент context - это контекст в виде словаря, который обновляется на месте при добавлении дополнительных переменных.

Flask.url_build_error_handlers:

Атрибут Flask.url_build_error_handlers содержит список функций, которые вызываются в момент появления ошибки BuildError, вызванной функцией flask.url_for().

Каждая зарегистрированная здесь функция вызывается с аргументами: ошибкой BuildError, конечной точкой и значениями. Если функция возвращает None или вызывает ошибку BuildError, производится попытка выполнения следующей функции.

Flask.url_default_functions:

Атрибут Flask.url_default_functions содержит структуру данных функций, вызываемых для изменения ключевых аргументов при генерации URL-адресов, в формате {scope: [functions]}. Ключ scope - это имя схемы blueprint, для которой активны функции, или None для всех запросов.

Чтобы зарегистрировать функцию, используйте декоратор Flask.url_defaults().

Это внутренняя структура данных. Ее нельзя изменять напрямую, и ее формат может измениться в любое время.

Flask.url_defaults(f):

Декоратор @Flask.url_defaults() регистрирует функцию f обратного вызова для значений URL по умолчанию для всех функций-представлений приложения.

В функцию f передается имя конечной точки и значения словаря dict. Функция f должна обновлять переданные значения.

Подробнее смотрите в разделе "Интернационализация приложения Flask при помощи URL-процессора".

Flask.url_map:

Атрибут Flask.url_map содержит карта URL-адресов для этого экземпляра приложения. Атрибут можно использовать для изменения конвертеров маршрутизации после создания класса, но до подключения каких-либо маршрутов.

from werkzeug.routing import BaseConverter

class ListConverter(BaseConverter):
    def to_python(self, value):
        return value.split(',')
    def to_url(self, values):
        return ','.join(super(ListConverter, self).to_url(value)
                        for value in values)

app = Flask(__name__)
app.url_map.converters['list'] = ListConverter

Flask.url_map_class:

Атрибут Flask.url_map_class представляет собой ссылку на класс werkzeug.routing.Map.

Flask.url_rule_class:

Атрибут Flask.url_rule_class представляет собой ссылку на класс werkzeug.routing.Rule.

Flask.url_value_preprocessor(f):

Декоратор Flask.url_value_preprocessor() регистрирует функцию препроцессора f значения URL для всех функций-представлений в приложении. Эти функции будут вызываться перед функциями, зарегистрированными декоратором Flask.before_request().

Функция может изменять значения, полученные из сопоставленного URL-адреса, прежде чем они будут переданы в представление. Например, это поведение можно использовать для извлечения из URL значения кода языка пользователя и помещения его в глобальный объект flask.g, а не для передачи его в каждое представление.

В функцию f передается имя конечной точки и значения словаря dict. Возвращаемое значение игнорируется.

Подробнее смотрите в разделе "Интернационализация приложения Flask при помощи URL-процессора".

Flask.url_value_preprocessors::

Атрибут Flask.url_value_preprocessors содержит структуру данных функций, вызываемых для изменения ключевых аргументов, переданных функции-представлению, в формате {scope: [functions]}. Ключ scope - это имя схемы blueprint, для которой активны функции, или None для всех запросов.

Чтобы зарегистрировать функцию, используйте декоратор Flask.url_value_preprocessor().

Это внутренняя структура данных. Ее нельзя изменять напрямую, и ее формат может измениться в любое время.

Flask.use_x_sendfile:

Атрибут Flask.use_x_sendfile если True, то позволяет использовать функцию X-Sendfile внешнего сервера. Атрибут умолчанию равен False. Сервер должен поддерживать такую функциональность.

Значение Flask.use_x_sendfile влияет только на файлы, отправленные с помощью функции flask.send_file(). Этот атрибут также можно настроить из конфигурации с помощью ключа конфигурации USE_X_SENDFILE.

Flask.view_functions:

Атрибут Flask.view_functions словарь, который сопоставляет имена конечных точек endpoint с функциями-представлениями.

Чтобы зарегистрировать функцию просмотра, используйте декоратор Flask.route().

Это внутренняя структура данных. Ее нельзя изменять напрямую, и ее формат может измениться в любое время.

Flask.wsgi_app(environ, start_response):

Метод Flask.wsgi_app() возвращает фактическое приложение WSGI. Это не реализовано в __call__(), следовательно промежуточное ПО можно применять без потери ссылки на объект приложения.

Например:

app = MyMiddleware(app)

Вместо этого лучше сделать следующее:

app.wsgi_app = MyMiddleware(app.wsgi_app)

Тогда все еще есть исходный объект приложения, и можно продолжать вызывать его методы.

Принимаемые аргументы:

  • environ: словарь с окружением WSGI.
  • start_response: вызываемый объект, который принимает код состояния, список заголовков и необязательный контекст исключения для запуска ответа.