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

Модульные приложения на схемах blueprint во Flask Python.

Создание расширяемых веб-приложения на Flask.

Фреимворк Flask использует концепцию схем blueprint для создания компонентов веб-приложения и поддержки общих шаблонов внутри приложения или между приложениями. Схемы blueprint могут значительно упростить работу больших веб-приложений, а так же предоставить расширения Flask для регистрации операций над приложениями. Объект Blueprint работает аналогично объекту приложения Flask, но на самом деле это не приложение. Скорее, это схема того, как создать или расширить приложение.

Содержание:


Что такое blueprint во Flask?

  1. Веб-приложение раскладывается на отдельные небольшие проекты/схемы (blueprint), что идеально подходит для крупных сайтов. Крупное приложение может создать экземпляр объекта приложения, инициализировать несколько расширений и зарегистрировать коллекцию проектов/схем blueprint.
  2. В веб-приложении регистрируется схема/проект с префиксом URL и/или поддоменом. Параметры в префиксе URL или поддомене становятся общими (со значениями по умолчанию) для всех функций-представлений в этой схеме/проекте blueprint.
  3. Может регистрировать схему blueprint несколько раз в приложении с разными правилами для URL. Например один и тот же код может работать на разных поддоменах, а информацию из базы данных можно брать, основываясь на имени поддомена (яркий пример - сайт предоставления каких то услуг, где город/область выступает в качестве поддомена).
  4. Предоставляет собственные фильтры, каталоги для статических файлов, шаблонов, а так же другие утилиты. Схема blueprint может не реализовывать собственные функции-представления, а только предоставлять какие-то ресурсы.
  5. Регистрирует схемы blueprint в приложении для любого из перечисленных случаев при инициализации стороннего расширения Flask.
Схемы blueprint во Flask не является подключаемым отдельным приложением, так как это не приложение - это набор операций, которые можно зарегистрировать в веб-приложении даже несколько раз. А почему бы не иметь несколько объектов одного приложения? Конечно это можно сделать, но в таком случае приложения будут иметь отдельные конфигурации и будут управляться на уровне WSGI.
Схемы blueprint обеспечивают разделение на уровне Flask, совместно используют конфигурацию приложения и могут при необходимости изменять объект приложения после регистрации. Недостатком такого подхода является то, что нельзя отменить регистрацию blueprint после того, как приложение было создано/запущено, без необходимости уничтожить весь объект приложения. Другими словами, нужно остановить работу сайта, закомментировать строку в которой регистрируется ненужный blueprint и снова запустить сайт.

Концепция blueprint.

Основная концепция схем элементов проекта blueprint состоит в том, что они записывают операции, которые необходимо выполнить при регистрации blueprint в приложении. Flask связывает функции-представления с blueprint при отправке запросов и генерации URL-адресов от одной конечной точки к другой.

Пример простой схемы blueprint во Flask.

Посмотрим как выглядит простая схема веб-приложения. Для примера реализуем схему blueprint, которая выполняет простой рендеринг статических шаблонов:
# файл схемы `blueprint` с именем `simple_page.py`
from flask import Blueprint, render_template, abort
from jinja2 import TemplateNotFound

# регистрируем схему `Blueprint`
simple_page = Blueprint('simple_page', __name__,
                        template_folder='templates')

# теперь в этой схеме, вместо экземпляра приложения 
# 'app' используем экземпляр `Blueprint` с именем `simple_page`. 
# Связываем URL со схемой `simple_page`
@simple_page.route('/', defaults={'page': 'index'})
@simple_page.route('/<page>')
def show(page):
    try:
        return render_template(f'pages/{page}.html')
    except TemplateNotFound:
        abort(404)
Когда функция show() привязывается с помощью декоратора @simple_page.route(), то Blueprint регистрирует ее как представление в приложении. Кроме того, перед маршрутом, переданным в @simple_page.route() будет стоять префикс с именем, который был передан конструктору Blueprint (в данном случае это simple_page). Таким образом, фактически страницы в примере будут работать по маршрутам /simple_page/index и /simple_page/<page>. В общем, название схемы blueprint не изменяет весь URL, а изменяет только конечную точку маршрута.

Как регистрировать blueprint в веб-приложении?

Регистрация blueprint в веб-приложении на Flask очень проста. Смотрим пример:
# файл __init__.py фактического веб-приложения
from flask import Flask
from yourapplication.simple_page import simple_page

app = Flask(__name__)
app.register_blueprint(simple_page)
Если проверить правила, зарегистрированные в приложении, то обнаружим следующее:
>>> app.url_map
# Map([<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
#  <Rule '/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
#  <Rule '/' (HEAD, OPTIONS, GET) -> simple_page.show>])
Первый URL '/static/<filename>', очевидно, из самого приложения для статических файлов. Два других предназначены для функции show() схемы simple_page. Как можно заметить, они также имеют префикс конечной точки с названием blueprint и разделены точкой ..
Начальные префиксы URL для схем blueprint могут быть изменены в момент регистрации конкретной схемы. Например:
app.register_blueprint(simple_page, url_prefix='/pages')
Смотрим сгенерированные правила:
app.url_map
Map([<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/pages/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
 <Rule '/pages/' (HEAD, OPTIONS, GET) -> simple_page.show>])
Кроме того, можно регистрировать blueprint несколько раз, хотя не все blueprint могут правильно на это отреагировать. Фактически, это зависит от того, как реализована данная схема blueprint.

Вложенные схемы blueprint во Flask.

Можно зарегистрировать blueprint в другом blueprint.
parent = Blueprint('parent', __name__, url_prefix='/parent')
child = Blueprint('child', __name__, url_prefix='/child')
parent.register_blueprint(child)
app.register_blueprint(parent)
Дочерняя схема получит имя родителя в качестве префикса к своему имени, а дочерние URL-адреса будут иметь префикс родительского URL-адреса.
url_for('parent.child.create')
# /parent/child/create
Специфичные для blueprint функции перед запросом и т. д., зарегистрированные у родителя, будут запускаться для дочернего элемента. Если у дочернего элемента нет обработчика ошибок, способного обработать данное исключение, то будет произведена попытка запуска обработчика ошибок родителя.

Собственные ресурсы blueprint.

Схемы blueprint также могут предоставлять собственные ресурсы. Иногда требоваться схема только для предоставления каких-то ресурсов.

Собственный каталог для хранения файлов схемы blueprint.

Как и в случае с обычными веб-приложениями, считается, что схемы blueprint должны находятся в каталогах. Хотя несколько blueprint могут находится в одном и том же каталоге, но это обычно не рекомендуется.
Папка для хранения схемы определяется вторым аргументом конструктора Blueprint, обычно это переменная __name__. Этот аргумент указывает, какой логический модуль или пакет Python соответствует схеме. Если он указывает на реальный пакет Python, то этот пакет (который является папкой в ​​файловой системе) является папкой ресурсов. Если это модуль, то пакет, в котором содержится модуль, будет папкой ресурсов. Чтобы узнать, что это за каталог, можно получить к нему доступ через Blueprint.root_path, :
>>> simple_page.root_path
# '/home/username/TestProject/yourapplication'
Чтобы быстро открывать исходники из этой папки, можно использовать функцию Blueprint.open_resource():
with simple_page.open_resource('static/style.css') as f:
    code = f.read()

Собственный каталог для статических файлов схемы blueprint.

Схема может предоставить доступ к каталогу со статическими файлами. Для этого необходимо передать в конструктор Blueprint путь к каталогу с аргументом static_folder. Это либо абсолютный путь, либо путь относительно расположения blueprint:
admin = Blueprint('admin', __name__, static_folder='static', url_prefix='/admin')
По умолчанию, самая правая часть пути - это место, которое будет отображаться в URL. Такое поведение поведение можно изменить с помощью аргумента static_url_path. Так как здесь папка называется static, то она будет доступна по префиксу url_prefix + /static. В примере в схеме есть префикс /admin, следовательно URL для статических файлов этого blueprint будет /admin/static.
Конечная точка примера будет называться 'admin.static' (правило 'blueprint_name.static_folder'). Можно сгенерировать URL-адрес для него с помощью flask.url_for(), как и для статической папки приложения:
url_for('admin.static', filename='style.css')
# /admin/static/style.css
НО, если схема blueprint не имеет url_prefix, то получить доступ к статической папке невозможно. Это связано с тем, что в этом случае у blueprint URL-адрес будет /static, а маршрут основного веб-приложения /static имеет приоритет.

Собственный каталог шаблонов для схемы blueprint.

Если необходимо, чтобы blueprint отображал шаблоны из собственной папки, то можно указать аргумент template_folder конструктору Blueprint при его создании:
admin = Blueprint('admin', __name__, template_folder='templates')
Папка шаблонов template_folder='templates', переданная в конструктор Blueprint добавляется в путь поиска шаблонов в flask.render_template(), но с более низким приоритетом, чем папка шаблонов фактического веб-приложения. Следовательно, можно легко переопределить шаблоны, предоставляемые blueprint, в папке шаблонов фактического веб-приложения. Что-бы этого случайно не произошло, необходимо убедиться, что никакой другой шаблон blueprint или шаблон фактического веб-приложения не имеет такого же относительного пути. Когда несколько blueprint предоставляют один и тот же относительный путь к шаблону, первый зарегистрированный blueprint имеет приоритет над другим.
Другими словами, если есть blueprint в папке yourapplication/admin, и необходимо отобразить шаблон admin/index.html, при этом был передан аргумент template_folder='templates' в конструктор Blueprint, то нужно будет создать файл cо следующим путем в файловой системе: yourapplication/admin/templates/admin/index.html. Причина создания дополнительной папки admin заключается в том, чтобы избежать переопределения этого шаблона, шаблоном с именем index.html в папке шаблонов фактического веб-приложения.
Повторяем еще раз: если есть blueprint с именем admin и необходимо отобразить специфичный для этого blueprint шаблон с именем index.html, то лучше всего расположить шаблоны следующим образом:
yourpackage/
    blueprints/
        admin/
            templates/
                admin/
                    index.html
            __init__.py
Затем, когда необходимо визуализировать шаблон, используйте путь admin/index.html в качестве имени для функции flask.render_template(). Если возникнут проблемы с загрузкой правильных шаблонов, то включите переменную конфигурации EXPLAIN_TEMPLATE_LOADING, которая скажет Flask напечатать шаги, которые он выполняет, чтобы найти шаблоны при каждом вызове flask.render_template().

Генерация URL-адресов url_for() для blueprint во Flask.

Схемы blueprint поддерживают функцию flask.url_for() для автоматического составления адреса до нужной страницы. Она используется так же, как обычно, правила составления такие: имя blueprint + . + имя функции-представления в этом blueprint:
url_for('admin.index')
Кроме того, если генерировать URL из функции-представлении этой схемы blueprint или шаблона, который предоставляет blueprint и надо связать с другой конечной точкой той же схемы blueprint, то можно использовать относительное имя конечной точки:
# будет ссылаться на `admin.index` если URL 
# генерируется из `blueprint` с именем `admin`
url_for('.index')

Обработчики ошибок для blueprint во Flask.

Схемы blueprint поддерживают декоратор обработчика ошибок так же, как объект приложения Flask, поэтому можно легко создавать специальные страницы ошибок для экземпляра Blueprint.
Пример страницы ошибки 404 Page Not Found для blueprint с именем simple_page:
@simple_page.errorhandler(404)
def page_not_found(e):
    return render_template('pages/404.html')
Большинство обработчиков ошибок будут просто работать должным образом, но есть предостережение относительно HTTP ошибок 404 и 405. Эти обработчики вызываются оператором raise или функцией flask.abort() только из функций-представления конкретной схемы. Они не вызываются, например, из-за недействительного доступа к URL-адресу. Это связано с тем, что blueprint не принадлежит определенное пространство URL-адресов, поэтому экземпляр приложения не знает, какой обработчик запустить, при недопустимом URL-адресе. Если необходимо выполнить различные стратегии обработки этих ошибок на основе префиксов URL-адресов, они могут быть определены на уровне фактического веб-приложения с помощью прокси-объекта запроса:
@app.errorhandler(404)
@app.errorhandler(405)
def _handle_api_error(ex):
    if request.path.startswith('/api/'):
        return jsonify(error=str(ex)), ex.code
    else:
        return ex
Как то так...

Класс flask.Blueprint(). Аргументы и основные декораторы.

Класс flask.Blueprint() представляет схему, набор маршрутов и другие функции, связанные с приложением, которые можно позже зарегистрировать в фактическом приложении.
Схема Blueprint - это объект, который позволяет определять функции приложения без предварительного запроса объекта приложения. Он использует те же декораторы, что и Flask, но откладывает необходимость регистрации в веб-приложении, записывая их для последующей регистрации.
Декорирование функции объектом схемы blueprint создает отложенную функцию-представление, которая вызывается, когда схема регистрируется в фактическом веб-приложении.

flask.Blueprint(name, import_name, static_folder=None, static_url_path=None, template_folder=None, url_prefix=None, subdomain=None, url_defaults=None, root_path=None, cli_group=<object object>)

Аргументы конструктора класса flask.Blueprint():
  • name (str) - Название схемы. Будет добавлено к каждому имени конечной точки.
  • import_name (str) - Имя пакета схемы, обычно __name__. Это помогает найти корневой путь для схемы.
  • static_folder=None (Optional[str]) – Папка со статическими файлами, которые должны обслуживаться статическим маршрутом схемы. Путь указывается относительно корневого пути схемы. По умолчанию статические файлы Blueprint отключены.
  • static_url_path=None (Optional[str]) – URL-адрес для обслуживания статических файлов. Если в схеме не указан url_prefix, то статический маршрут фактического веб-приложения будет иметь приоритет, а статические файлы схемы будут недоступны.
  • template_folder=None (Optional[str]) – Папка с шаблонами, которую нужно добавить в путь поиска шаблонов приложения. Путь указывается относительно корневого пути схемы. По умолчанию шаблоны Blueprint отключены. Шаблоны Blueprint имеют более низкий приоритет, чем шаблоны в папке шаблонов фактического веб-приложения.
  • url_prefix=None (Optional[str]) – Путь, добавляемый ко всем URL-адресам схемы, чтобы отличать их от остальных маршрутов приложения.
  • subdomain=None (Optional[str]) – Поддомен, для которого маршруты схемы будут совпадать по умолчанию.
  • url_defaults=None (Optional[dict]) – Словарь, для изменяемых значений маршрутов, зарегистрированных в схеме, которые они будут получать по умолчанию. Ключ словаря - имя переменной изменяемой части маршрута.
  • root_path (Optional[str]) – По умолчанию схема автоматически устанавливает root_path на основе import_name. В определенных ситуациях это автоматическое обнаружение может дать сбой, поэтому путь можно указать вручную.

Объект Blueprint, основные методы и декораторы.

Внимание! Здесь рассмотрены только часто используемые методы и декораторы объекта Blueprint.

Содержание:


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

Метод blueprint.add_url_rule() работает так же как Flask.add_url_rule(), только для blueprint.
Для функции flask.url_for(), конечная точка имеет префикс с именем схемы, например 'name_blueprint.view_func'.
from flask import url_for, Blueprint, redirect

# имя схемы 'admin', объект схемы `main`
main = Blueprint('admin', __name__)

# Правила маршрутизации для схемы
main.add_url_rule('/', view_func=index)
main.add_url_rule('/results', view_func=results)

# функции-представления данной схемы

def index():
    # внимание, `url_for()` имеет префикс 
    # названия схемы `admin` и через точку 
    # имя функции-представления `results`
    return redirect(url_for('admin.results'))

def results():
    # some code
    return 'some results'

blueprint.after_app_request(f, resp):

Декоратор blueprint.after_app_request() регистрирует функцию f, которая выполняется после каждого запроса, даже если она находится вне схемы. Работает как Flask.after_request(), но только для blueprint.
Функция f вызывается с объектом resp (передается автоматически) и должна возвращать объект resp. Это позволяет функциям изменять или заменять ответ до его отправки.

blueprint.after_request(f, resp):

Декоратор blueprint.after_request() регистрирует функцию f которая выполняется после каждого запроса к этому blueprint.
Функция f вызывается с объектом ответа resp (передается автоматически) и должна возвращать объект ответа. Это позволяет функциям изменять или заменять ответ перед его отправкой.
Если функция вызывает исключение, все оставшиеся функции в blueprint.after_request вызываться не будут. Следовательно, ее не следует использовать для действий, которые обязательны к выполнению, например, для закрытия ресурсов. Для этого используйте blueprint.teardown_request().

blueprint.app_errorhandler(code):

Декоратор blueprint.app_errorhandler() работает как Flask.errorhandler(), но только для blueprint.
Этот обработчик используется для всех запросов, даже если они не входят в схему.

blueprint.app_template_filter(name=None):

Декоратор blueprint.app_template_filter() регистрирует фильтр для шаблона схемы.
Работает как Flask.template_filter(), только для blueprint.
@blueprint.app_template_filter('my_multiplier')
def my_multiplier(n):
    return n*10

blueprint.app_template_test(name=None):

Метод blueprint.app_template_test() регистрирует пользовательский тест для шаблона схемы blueprint.
Декоратор как Flask.template_test(), только для blueprint.
@blueprint.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

blueprint.before_request(f):

Декоратор blueprint.before_request() регистрирует функцию, которая будет запускаться перед каждым запросом.
Например, это можно использовать для открытия соединения с базой данных или для загрузки вошедшего в систему пользователя из сеанса.
@blueprint.before_request
def load_user():
    if "user_id" in session:
        g.user = db.session.get(session["user_id"])
Функция будет вызываться без аргументов. Если функция возвращает значение, отличное от None, то значение обрабатывается так, как если бы оно было значением, возвращаемым из функции-представления, и дальнейшая обработка запроса прекращается.

blueprint.delete(rule, **options):

Декоратор blueprint.delete() - ссылка на blueprint.route() с уже переданным аргументом methods=["DELETE"].
@blueprint.delete('/api/del/<int:id>')
def del(id)
    ...

# эквивалентно
@blueprint.route('/api/del/<int:id>', methods=['DELETE'])
def del(id)
    ...
Новое в версии 2.0.

blueprint.endpoint(endpoint):

Декоратор blueprint.endpoint() для функции-представления, который регистрирует ее для данной конечной точки endpoint. Используется, если маршрут добавляется с помощью blueprint.add_url_rule().
blueprint.add_url_rule("/ex", endpoint="example")

@blueprint.endpoint('example')
def sample():
    ...
  • endpoint (str) – имя конечной точки, связываемое с функцией-представлением.

blueprint.errorhandler(code_or_exception):

Декоратор blueprint.errorhandler() регистрирует функцию для обработки ошибок по HTTP-коду или классу исключения.
  • code_or_exception - код ошибки или исключение.
Пример декоратора, который используется для регистрации функции с кодом ошибки:
@blueprint.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404
Можно также зарегистрировать обработчики для произвольных исключений:
@blueprint.errorhandler(DatabaseError)
def special_exception_handler(error):
    return 'Database connection failed', 500

blueprint.get(rule, **options):

Декоратор blueprint.get() ссылка на blueprint.route() с уже переданным аргументом methods=["GET"].
@blueprint.get('/<int:id>')
def view(id)
    ...

# эквивалентно
@blueprint.route('/<int:id>', methods=['GET'])
def view(id)
    ...
Новое в версии 2.0.

blueprint.get_send_file_max_age(filename):

Метод blueprint.get_send_file_max_age() используется flask.send_file() для определения значения кеша max_age для заданного пути к файлу, если оно не было передано.
По умолчанию метод возвращает SEND_FILE_MAX_AGE_DEFAULT из конфигурации current_app. По умолчанию это значение None, что указывает браузеру использовать условные запросы вместо кеширования по времени, что обычно предпочтительнее.
Изменено в версии 2.0: Конфигурация по умолчанию - None, вместо 12 часов.

blueprint.has_static_folder: bool:

Свойство blueprint.has_static_folder возвращает True, если установлена blueprint.static_folder.

blueprint.import_name:

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

blueprint.jinja_loader:

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

blueprint.json_decoder:

Атрибут blueprint.json_decoder локальный класс декодера JSON для этой схемы. Установите значение None, чтобы использовать json_decoder фактического веб-приложения.

blueprint.json_encoder:

Атрибут blueprint.json_encoder локальный класс кодировщика JSON для этой схемы. Установите значение None, чтобы использовать json_encoder фактического веб-приложения.

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

Метод blueprint.open_resource() открывает файл ресурсов относительно blueprint.root_path для чтения.
  • resource: строка, путь к ресурсу относительно blueprint.root_path.
  • mode: строка с режимом открытия файла. Поддерживается только чтение, допустимые значения - 'r' и 'rb'.
Например, если файл schema.sql находится рядом с файлом blueprint_name.py, в котором определено приложение Flask, то его можно выполнить с помощью следующего кода:
with blueprint_name.open_resource("schema.sql") as f:
    conn.executescript(f.read())

blueprint.patch(rule, **options):

Декоратор blueprint.patch() ссылка на blueprint.route() с уже подставленным аргументом methods=["PATCH"].
@blueprint.patch('/sample/<int:id>')
def sample(id)
    ...

# эквивалентно
@blueprint.route('/sample/<int:id>', methods=['PATCH'])
def sample(id)
    ...
Новое в версии 2.0.

blueprint.post(rule, **options):

Декоратор blueprint.post() ссылка на blueprint.route() с уже подставленным аргументом methods=["POST"].
@blueprint.post('/sample/<int:id>')
def sample(id)
    ...

# эквивалентно
@blueprint.route('/sample/<int:id>', methods=['POST'])
def sample(id)
    ...
Новое в версии 2.0.

blueprint.put(rule, **options):

Декоратор blueprint.put() ссылка на blueprint.route() с уже подставленным аргументом methods=["PUT"].
@blueprint.put('/sample/<int:id>')
def sample(id)
    ...

# эквивалентно
@blueprint.route('/sample/<int:id>', methods=['PUT'])
def sample(id)
    ...
Новое в версии 2.0.

blueprint.register_blueprint(blueprint, **options):

Метод blueprint.register_blueprint() регистрирует другой blueprint в этом blueprint. Ключевые аргументы, переданные этому методу, переопределят значения по умолчанию, установленные в схеме.
Пример использования смотрите выше, в подразделе "Вложенные схемы blueprint во Flask"
Новое в версии 2.0.

blueprint.register_error_handler(code_or_exception, f):

Метод blueprint.register_error_handler() - альтернативная функция присоединения ошибки к декоратору @blueprint.errorhandler(), более простая для использования без использования декоратора.
  • code_or_exception - код ошибки или исключение,
  • f - функция обработчик этой ошибки, определенная в коде схемы blueprint.

blueprint.root_path:

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

blueprint.route(rule, **options):

Декоратор blueprint.route() применяется к функции, которая отображает страницу по указанному маршруту rule. Вызывает blueprint.add_url_rule(), которая имеет более подробную информацию о реализации.
@blueprint.route("/")
def index():
    return "Hello, World!"
Ключевые аргументы **options:
  • endpoint=None: Конечная точка для этого правила. Это может быть что угодно. Ссылка на функцию, строка, число и т. д. Предпочтительный способ - использовать строку, потому что конечная точка используется для генерации URL flask.url_for().
    Если endpoint не задан, то по умолчанию используется имя функции, которая генерирует и отображает страницу,
  • defaults=None: Словарь dict со значениями по умолчанию для других правил с тем же endpoint. Немного сложно понять, но очень полезная штука, если надо иметь уникальные URL-адреса.
    Пример:
    @blueprint.route('/all/', defaults={'page': 1}, endpoint='all_entries')
    @blueprint.route('/all/page/<int:page>', endpoint='all_entries')
    def all(page):
    ...
    
    Если пользователь посетит http://example.com/all/page/1, он будет перенаправлен на http://example.com/all/.
  • methods=['GET']: Список HTTP-методов, к которым применяется это правило. По умолчанию доступен метод GET. Например, это может быть полезно, если нужны разные конечные точки для POST и GET. Если методы определены и путь совпадает, но соответствующий метод отсутствует в этом списке или в списке другого правила для этого пути, то возникает ошибка типа MethodNotAllowed, а не NotFound. Если GET присутствует в списке методов, а HEAD нет, то HEAD добавляется автоматически. OPTIONS добавляются автоматически.
  • subdomain: задает правило для поддомена в случае, если используется сопоставление поддоменов. Если не указано, предполагается субдомен по умолчанию.
  • strict_slashes=True: Если маршрут заканчивается косой чертой, а соответствующий URL-адрес - нет, то перенаправляет на URL-адрес с конечной косой чертой.
    Например если маршрут задан как @blueprint.route('/section/20/'), а пользователь набрал URL-адрес http://example.org/section/20, то пользователь будет перенаправлен на http://example.org/section/20/.
  • merge_slashes=True: Объединяет последовательные косые черты при сопоставлении или создании URL-адресов. Совпадения будут перенаправлены на нормализованный URL. Косые черты в изменяемых частях URL не объединяются.
    Например URL-адрес http://example.org///section//20 будет нормализован и перенаправлен на http://example.org/section/20
  • redirect_to: если задано, то это должно быть либо строка URL, либо вызываемая функция. В случае вызываемого объекта (функции), то она вызывается с адаптером URL, который инициировал сопоставление, и значениями URL в качестве ключевых аргументов и должна возвращать цель для перенаправления (URL-адрес), в противном случае это должна быть строка маршрута:
    Пример:
    # Функция, которая генерирует новые URL-адреса
    def foo_with_slug(adapter, id):
      # запросить в базе данных `id` для старого идентификатора.
      return f'foo/{Foo.get_slug_for_id(id)}'
    
    @blueprint.route('/foo/<slug>')
    def all(page):
    ...
    
    # правила перенаправлений на новые URL-адреса
    app.add_url_rule('/some/old/url/<slug>', redirect_to='foo/<slug>') 
    app.add_url_rule('/other/old/url/<int:id>', redirect_to=foo_with_slug)
    

blueprint.send_static_file(filename):

Метод blueprint.send_static_file() используется для обслуживания файлов из blueprint.static_folder. Маршрут автоматически регистрируется для этого представления в blueprint.static_url_path, если установлен ​​blueprint.static_folder.
from flask import Blueprint, request
# установим корневой каталог проекта в качестве статической
# папки `static_url_path=''` (можно установить другое значение).
bp = Blueprint('frontend', __name__, static_url_path='')

@bp.route('/')
def root_send_file():
    return app.send_static_file('index.html')
Не используйте blueprint.send_static_file с пользовательским маршрутом, например @blueprint.route('/js/<path:path>'). Маршрут регистрируется автоматически!!!

blueprint.static_folder:

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

blueprint.static_url_path: Optional[str]:

Свойство blueprint.static_url_path - префикс URL-адреса, с которого будет доступен маршрут со статическими файлами.
Если static_url_path не был настроен во время инициализации схемы, то значение является производным от blueprint.static_folder.

blueprint.teardown_app_request(f):

Метод blueprint.teardown_app_request() выполняет функцию f при разрыве каждого запроса, даже если он находится вне схемы.
Работает как Flask.teardown_request(), но для схемы blueprint.

blueprint.teardown_request(f):

Метод blueprint.teardown_request() регистрирует функцию f, которая будет запускаться в конце каждого запроса, независимо от того, было ли исключение или нет. Эти функции выполняются при открытии контекста запроса, даже если фактический запрос не был выполнен.
Пример:
ctx = app.test_request_context()
ctx.push()
...
ctx.pop()
Когда в приведенном выше примере выполняется ctx.pop(), то .pop() вызывается непосредственно перед перемещением контекста запроса из стека активных контекстов. Это становится актуальным, если такие конструкции используются в тестах.
Функции в blueprint.teardown_request() не должны вызывать исключения. Если они выполняют код, который может дать сбой, то придется окружать выполнение этого кода операторами try/except и регистрировать возникающие ошибки.
Если метод blueprint.teardown_request() вызывается из-за исключения, то ему передается объект ошибки.
Возвращаемые значения функций игнорируются.
Примечание: В режиме отладки Flask не будет немедленно отключать запрос об исключении. Вместо этого он будет поддерживать его в рабочем состоянии, чтобы интерактивный отладчик мог получить к нему доступ. Этим поведением можно управлять с помощью переменной конфигурации PRESERVE_CONTEXT_ON_EXCEPTION.

blueprint.template_folder:

Атрибут blueprint.template_folder представляет собой путь к папке шаблонов относительно blueprint.root_path, который добавляется в загрузчик шаблонов flask.render_template() первым аргументом.

blueprint.url_defaults(f):

Декоратор blueprint.url_defaults() предназначен для установки значений URL по умолчанию для всех функций-представлений схемы.
Функции f, которая следует за декоратором, передается имя конечной точки endpoint (по умолчанию, это имя функция-представление определенного маршрута) и значения словаря values, в котором ключи - это имена переменных изменяемой части маршрута. Эта функция должна устанавливать значения по умолчанию для переменных изменяемой части маршрута.
from flask import Blueprint, g

# регистрируем схему с названием `frontend` 
bp = Blueprint('frontend', __name__, url_prefix='/<lang_code>')

# Допустим пользователь выбрал язык сайта как `ru`
# и URL-адреса для этой схемы стали с префиксом `/ru`,  
# следовательно `lang_code` в `url_prefix` стала равной 'ru'

# извлекаем из словаря `values`, который передается 
# автоматически в функцию `pull_lang_code()` и имеет 
# вид {'lang_code':'ru'}, значение `lang_code`, далее 
# записываем ее значение в глобальный объект `g`
@bp.url_value_preprocessor
def pull_lang_code(endpoint, values):
    g.lang_code = values.pop('lang_code')

# теперь для всех URL схемы, по умолчанию, будем 
# изменять ключ `lang_code` на значение 'ru' словаря 
# `values`, который в свою очередь отвечает за `url_prefix` 
@bp.url_defaults
def add_language_code(endpoint, values):
    values.setdefault('lang_code', g.lang_code)

# здесь маршрут будет `/ru`
@bp.route('/')
def index():
    ...

# здесь маршрут будет `/ru/about`
@bp.route('/about')
def about():
    ...

blueprint.url_value_preprocessor(f):

Декоратор blueprint.url_value_preprocessor() регистрирует функцию препроцессора f, для всех функций-представлений в схеме. Эта функция будет вызываться перед функцией blueprint.before_request().
Декорированная функция f может просматривать изменяемые значения маршрута, полученные из сопоставленного URL-адреса, прежде чем они будут переданы в представление. Например, это можно использовать для извлечения каких то значений из URL и помещения его в глобальный объект flask.g, а не для передачи этих значений в каждое представление.
Функции f, которая следует за декоратором, передается имя конечной точки endpoint (по умолчанию, это имя функция-представление определенного маршрута) и значения словаря values, в котором ключи - это имена переменных изменяемой части маршрута.
Возвращаемое значение игнорируется.
Пример использования смотрите в описании декоратора blueprint.url_defaults.