Маршрутизация URL

При объединении нескольких функций контроллера или представления (как бы вы их ни называли) вам нужен диспетчер. Простой способ — применение тестов с регулярными выражениями к PATH_INFO и вызов зарегистрированных функций обратного вызова, возвращающих значение.

Werkzeug предоставляет гораздо более мощную систему, аналогичную Routes. Все объекты, упомянутые на этой странице, должны импортироваться из werkzeug.routing, а не из werkzeug!

Быстрый старт

Вот простой пример определения URL для блога:

from werkzeug.routing import Map, Rule, NotFound, RequestRedirect

url_map = Map([
    Rule('/', endpoint='blog/index'),
    Rule('/<int:year>/', endpoint='blog/archive'),
    Rule('/<int:year>/<int:month>/', endpoint='blog/archive'),
    Rule('/<int:year>/<int:month>/<int:day>/', endpoint='blog/archive'),
    Rule('/<int:year>/<int:month>/<int:day>/<slug>',
         endpoint='blog/show_post'),
    Rule('/about', endpoint='blog/about_me'),
    Rule('/feeds/', endpoint='blog/feeds'),
    Rule('/feeds/<feed_name>.rss', endpoint='blog/show_feed')
])

def application(environ, start_response):
    urls = url_map.bind_to_environ(environ)
    try:
        endpoint, args = urls.match()
    except HTTPException, e:
        return e(environ, start_response)
    start_response('200 OK', [('Content-Type', 'text/plain')])
    return ['Rule points to %r with arguments %r' % (endpoint, args)]

Что это делает? Прежде всего, мы создаём новый Map, который хранит множество правил URL. Затем мы передаём ему список объектов Rule.

Каждый объект Rule инициализируется строкой, представляющей правило, и конечной точкой, которая будет псевдонимом для представления, которое представляет правило. Несколько правил могут иметь одинаковую конечную точку, но должны иметь разные аргументы для построения URL.

Формат правил URL прост, но подробно описан ниже.

Внутри приложения WSGI мы связываем url_map с текущим запросом, что вернёт новый MapAdapter. Этот адаптер url_map можно использовать для сопоставления или построения доменов для текущего запроса.

Метод MapAdapter.match() может вернуть кортеж в формате (endpoint, args) или вызвать одно из трёх исключений NotFound, MethodNotAllowed или RequestRedirect. Более подробную информацию об этих исключениях можно найти в документации метода MapAdapter.match().

Формат правила

Строки правил представляют собой обычные пути URL с плейсхолдерами в формате <converter(arguments):name>, где преобразователь и аргументы являются необязательными. Если преобразователь не определён, используется преобразователь default (что означает string в стандартной конфигурации).

Правила URL, заканчивающиеся слешем, являются ветвями URL, другие — листьями. Если включён strict_slashes (по умолчанию), все ветви URL, которые посещаются без заключительного слеша, будут перенаправлены на тот же URL с добавленным слешем.

Список преобразователей можно расширить, ниже описаны стандартные преобразователи.

Встроенные преобразователи

Вот список преобразователей, которые поставляются с Werkzeug:

class werkzeug.routing.UnicodeConverter(map, minlength=1, maxlength=None, length=None)

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

Это стандартный валидатор.

Пример:

Rule('/pages/<page>'),
Rule('/<string(length=2):lang_code>')

Параметры:	map – Map. minlength – минимальная длина строки. Должна быть больше или равна 1. maxlength – максимальная длина строки. length – точная длина строки.

class werkzeug.routing.PathConverter(map)

Подобно стандартному UnicodeConverter, но также соответствует слешам. Это полезно для вики и аналогичных приложений:

Rule('/<path:wikipage>')
Rule('/<path:wikipage>/edit')

Параметры:	map – Map.

class werkzeug.routing.AnyConverter(map, *items)

Сопоставляет один из предоставленных элементов. Элементы могут быть либо идентификаторами Python, либо строками:

Rule('/<any(about, help, imprint, class, "foo,bar"):page_name>')

Параметры:	map – Map. items – эта функция принимает возможные элементы в качестве позиционных аргументов.

class werkzeug.routing.IntegerConverter(map, fixed_digits=0, min=None, max=None, signed=False)

Этот преобразователь принимает только целочисленные значения:

Rule("/page/<int:page>")

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

Rule("/page/<int(signed=True):page>")

Параметры:	map – Map. fixed_digits – количество фиксированных цифр в URL. Если вы установите это значение, например, на 4, правило будет соответствовать только URL-адресам вида /0001/. По умолчанию используется переменная длина. min – минимальное значение. max – максимальное значение. signed – разрешить знакомые (отрицательные) значения.

Добавлен в версии 0.15: Параметр signed.

class werkzeug.routing.FloatConverter(map, min=None, max=None, signed=False)

Этот преобразователь принимает только значения с плавающей точкой:

Rule("/probability/<float:probability>")

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

Rule("/offset/<float(signed=True):offset>")

Параметры:	map – Map. min – минимальное значение. max – максимальное значение. signed – разрешить знакомые (отрицательные) значения.

Добавлен в версии 0.15: Параметр signed.

class werkzeug.routing.UUIDConverter(map)

Этот преобразователь принимает только строки UUID:

Rule('/object/<uuid:identifier>')

Добавлен в версии 0.10.

Параметры:	map – Map.

Карты, правила и адаптеры

class werkzeug.routing.Map(rules=None, default_subdomain='', charset='utf-8', strict_slashes=True, redirect_defaults=True, converters=None, sort_parameters=False, sort_key=None, encoding_errors='replace', host_matching=False)

Класс карты хранит все правила URL и некоторые параметры конфигурации. Некоторые значения конфигурации хранятся только в экземпляре Map , так как они влияют на все правила, другие являются просто значениями по умолчанию и могут быть переопределены для каждого правила. Обратите внимание, что вы должны указать все аргументы, кроме rules, в качестве именованных аргументов!

Параметры:

rules – последовательность правил URL для этой карты. default_subdomain – Поддомен по умолчанию для правил без указанного поддомена. charset – кодировка символов URL. По умолчанию "utf-8" strict_slashes – Учет слешей в конце. redirect_defaults – Перенаправляет на правило по умолчанию, если оно не было посещено таким образом. Это помогает создавать уникальные URL. converters – Словарь конвертеров, добавляющий дополнительные конвертеры в список конвертеров. Если вы переопределяете конвертер, он перекроет исходный. sort_parameters – Если установлено в True, параметры URL сортируются. Смотрите url_encode для получения более подробной информации. sort_key – Функция сортировки ключей для url_encode. encoding_errors – Метод обработки ошибок при декодировании host_matching – Если установлено в True, оно включает функцию сопоставления по хосту и отключает функцию поддоменов. Если включено, параметр host в правилах используется вместо subdomain.

Добавлено в версии 0.5: sort_parameters и sort_key были добавлены.

Добавлено в версии 0.7: encoding_errors и host_matching были добавлены.

converters

Словарь конвертеров. Он может быть изменён после создания класса, но это повлияет только на правила, добавленные после изменения. Если правила определены со списком, переданным в класс, вместо этого следует использовать параметр converters конструктора.

add(rulefactory)

Добавляет новое правило или фабрику в карту и привязывает её. Требуется, чтобы правило не было привязано к другой карте.

Параметры:	rulefactory – Rule или RuleFactory

bind(server_name, script_name=None, subdomain=None, url_scheme='http', default_method='GET', path_info=None, query_args=None)

Возвращает новую MapAdapter с указанными деталями. Обратите внимание, что script_name по умолчанию будет '/' если не указано или None. Параметр server_name необходим, так как HTTP RFC требует абсолютных URL для перенаправлений, и поэтому все исключения перенаправления, поднятые Werkzeug, будут содержать полный канонический URL.

Если в match() не указан path_info, он будет использовать путь по умолчанию, переданный в bind. Хотя это не имеет смысла для вызовов bind вручную, это полезно, если вы привязываете карту к среде WSGI, которая уже содержит path_info.

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

Добавлено в версии 0.7: query_args добавлен

Добавлено в версии 0.8: query_args теперь также может быть строкой.

Изменено в версии 0.15: path_info по умолчанию '/' если None.

bind_to_environ(environ, server_name=None, subdomain=None)

Аналогично bind(), но вы можете передать среду WSGI, и она извлечёт информацию из этого словаря. Учитывая ограничения протокола, нет возможности получить текущий поддомен и фактический server_name из среды. Если вы не укажете, Werkzeug будет использовать SERVER_NAME и SERVER_PORT (или HTTP_HOST если указано), используемые server_name с отключённой функцией поддоменов.

Если subdomain None, но передана среда и имя сервера, текущий поддомен будет рассчитан автоматически. Пример: server_name 'example.com', и SERVER_NAME в wsgi environ 'staging.dev.example.com', рассчитанный поддомен будет 'staging.dev'.

Если у объекта, переданного как environ, есть атрибут environ, используется значение этого атрибута. Это позволяет передавать объекты запроса. Кроме того, PATH_INFO добавлен по умолчанию в MapAdapter, чтобы вам не приходилось передавать path_info в метод match.

Изменено в версии 0.5: ранее этот метод принимал бесполезный calculate_subdomain параметр, который не имел никакого эффекта. Он был удален из-за этого.

Изменено в версии 0.8: Этот метод больше не будет поднимать ValueError при передаче неожиданного имени сервера.

Параметры:	environ – среда WSGI. server_name – необязательное имя сервера (см. выше). subdomain – необязательно, текущий поддомен (см. выше).

default_converters = {'any': <class 'werkzeug.routing.AnyConverter'>, 'default': <class 'werkzeug.routing.UnicodeConverter'>, 'float': <class 'werkzeug.routing.FloatConverter'>, 'int': <class 'werkzeug.routing.IntegerConverter'>, 'path': <class 'werkzeug.routing.PathConverter'>, 'string': <class 'werkzeug.routing.UnicodeConverter'>, 'uuid': <class 'werkzeug.routing.UUIDConverter'>}

Словарь конвертеров по умолчанию.

is_endpoint_expecting(endpoint, *arguments)

Перебирает все правила и проверяет, ожидает ли конечная точка предоставленные аргументы. Это, например, полезно, если у вас есть некоторые URL, которые ожидают код языка, а другие — нет, и вы хотите обернуть генератор, чтобы код текущего языка добавлялся автоматически, если он не предоставлен, но конечные точки его ожидают.

Параметры:	endpoint – конечная точка для проверки. arguments – эта функция принимает один или несколько аргументов в качестве позиционных аргументов. Каждый из них проверяется.

iter_rules(endpoint=None)

Перебирает все правила или правила конечной точки.

Параметры:	endpoint – если указано, возвращаются только правила для этой конечной точки.
Возвращает:	итератор

update()

Вызывается перед сопоставлением и построением, чтобы сохранить скомпилированные правила в правильном порядке после изменений.

class werkzeug.routing.MapAdapter(map, server_name, script_name, subdomain, url_scheme, path_info, default_method, query_args=None)

Возвращается методом Map.bind() или Map.bind_to_environ() и выполняет сопоставление и построение URL на основе данных выполнения.

allowed_methods(path_info=None)

Возвращает допустимые методы, которые соответствуют заданному пути.

Добавлена в версии 0.7.

build(endpoint, values=None, method=None, force_external=False, append_unknown=True)

Построение URL работает примерно наоборот. Вместо match вы вызываете build и передаете ему конечную точку и словарь аргументов для заполнитель.

Функция build также принимает аргумент, называемый force_external, который, если установить его в True, принудительно создаст внешние URL-адреса. По умолчанию внешние URL-адреса (включая имя сервера) будут использоваться только в том случае, если целевой URL-адрес находится на другой поддомен.

>>> m = Map([
...     Rule('/', endpoint='index'),
...     Rule('/downloads/', endpoint='downloads/index'),
...     Rule('/downloads/<int:id>', endpoint='downloads/show')
... ])
>>> urls = m.bind("example.com", "/")
>>> urls.build("index", {})
'/'
>>> urls.build("downloads/show", {'id': 42})
'/downloads/42'
>>> urls.build("downloads/show", {'id': 42}, force_external=True)
'http://example.com/downloads/42'

Поскольку URL-адреса не могут содержать данные, не являющиеся ASCII, вы всегда будете получать байтовые строки. Символы, не являющиеся ASCII, будут закодированы в URL с помощью набора символов, определенного в экземпляре карты.

Дополнительные значения преобразуются в unicode и добавляются к URL в качестве параметров строки запроса:

>>> urls.build("index", {'q': 'My Searchstring'})
'/?q=My+Searchstring'

При обработке этих дополнительных значений списки также интерпретируются как несколько значений (согласно werkzeug.datastructures.MultiDict):

>>> urls.build("index", {'q': ['a', 'b', 'c']})
'/?q=a&q=b&q=c'

Передача MultiDict также добавит несколько значений:

>>> urls.build("index", MultiDict((('p', 'z'), ('q', 'a'), ('q', 'b'))))
'/?p=z&q=a&q=b'

Если правило не существует при построении BuildError возникает исключение.

Метод build принимает аргумент, называемый method, который позволяет указать метод, для которого нужно построить URL, если для одной и той же конечной точки определены различные методы.

Добавлена в версии 0.6: параметр append_unknown был добавлен.

Параметры:

endpoint – конечная точка URL для построения. values – значения для построения URL. Необработанные значения добавляются к URL в качестве параметров запроса. method – HTTP-метод для правила, если для одной и той же конечной точки существуют разные URL для разных методов. force_external – принудительно создавать полные канонические внешние URL-адреса. Если схема URL не указана, это сгенерирует URL-адрес с относительным протоколом. append_unknown – неизвестные параметры добавляются к сгенерированному URL как аргумент строки запроса. Отключите это, если вы хотите, чтобы билдер игнорировал их.

dispatch(view_func, path_info=None, method=None, catch_http_exceptions=False)

Выполняет весь процесс диспетчеризации. view_func вызывается с конечной точкой и словарем со значениями для представления. Он должен найти функцию представления, вызвать ее и вернуть объект ответа или WSGI-приложение. Исключение http по умолчанию не перехватывается, чтобы приложения могли отображать более приятные сообщения об ошибках, просто перехватывая их вручную. Если вы хотите придерживаться сообщений об ошибках по умолчанию, вы можете передать catch_http_exceptions=True и он перехватит исключения http.

Вот небольшой пример использования dispatch:

from werkzeug.wrappers import Request, Response
from werkzeug.wsgi import responder
from werkzeug.routing import Map, Rule

def on_index(request):
    return Response('Hello from the index')

url_map = Map([Rule('/', endpoint='index')])
views = {'index': on_index}

@responder
def application(environ, start_response):
    request = Request(environ)
    urls = url_map.bind_to_environ(environ)
    return urls.dispatch(lambda e, v: views[e](request, **v),
                         catch_http_exceptions=True)

Помните, что этот метод также может вернуть объекты исключений, поэтому используйте Response.force_type для получения объекта ответа.

Параметры:

view_func – функция, которая вызывается с конечной точкой в качестве первого аргумента и словарем значений как второго. Должна перенаправлять на фактическую функцию представления с этой информацией. (см. выше) path_info – информация о пути для использования при сопоставлении. Переопределяет информацию о пути, указанную при связывании. method – HTTP-метод, используемый для сопоставления. Переопределяет метод, указанный при связывании. catch_http_exceptions – установить в True для перехвата любых исключений werkzeug HTTPException.

get_host(domain_part)

Определяет полное имя хоста для заданной части домена. Часть домена — это поддомен, если сопоставление хостов отключено, или полное имя хоста.

make_alias_redirect_url(path, endpoint, values, method, query_args)

Внутренне вызывается для создания URL-адреса перенаправления псевдонима.

match(path_info=None, method=None, return_rule=False, query_args=None)

Использование простое: вы просто передаете метод match текущий путь, а также метод (по умолчанию GET). Тогда могут произойти следующие события:

• вы получите исключение NotFound, которое указывает, что ни один URL не соответствует. Исключение NotFound также является WSGI-приложением, которое можно вызвать для получения страницы по умолчанию, не найденной (является тем же объектом, что и werkzeug.exceptions.NotFound)
• вы получите исключение MethodNotAllowed, которое указывает, что существует соответствие для данного URL, но не для текущего метода запроса. Это полезно для приложений REST.
• вы получите исключение RequestRedirect, с атрибутом new_url. Это исключение используется для уведомления о запросе Werkzeug requests от вашего WSGI-приложения. Например, это происходит, если вы запрашиваете /foo, хотя правильный URL /foo/ Вы можете использовать экземпляр RequestRedirect как объект ответа, аналогично всем другим подклассам HTTPException.
• вы получите кортеж в виде (endpoint, arguments), если есть совпадение (если только return_rule не равно True, в этом случае вы получите кортеж в виде (rule, arguments))

Если информация о пути не передается методу match, используется информация о пути по умолчанию для карты (по умолчанию — корневой URL, если он не определен явно).

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

Вот небольшой пример сопоставления:

>>> m = Map([
...     Rule('/', endpoint='index'),
...     Rule('/downloads/', endpoint='downloads/index'),
...     Rule('/downloads/<int:id>', endpoint='downloads/show')
... ])
>>> urls = m.bind("example.com", "/")
>>> urls.match("/", "GET")
('index', {})
>>> urls.match("/downloads/42")
('downloads/show', {'id': 42})

И вот что происходит при перенаправлении и отсутствии URL:

>>> urls.match("/downloads")
Traceback (most recent call last):
  ...
RequestRedirect: http://example.com/downloads/
>>> urls.match("/missing")
Traceback (most recent call last):
  ...
NotFound: 404 Not Found

Параметры:

path_info – информация о пути для использования при сопоставлении. Переопределяет информацию о пути, указанную при связывании. method – HTTP-метод, используемый для сопоставления. Переопределяет метод, указанный при связывании. return_rule – вернуть правило, которое соответствовало, а не только конечную точку (по умолчанию False). query_args – необязательные аргументы запроса, используемые для автоматических перенаправлений в виде строки или словаря. В настоящее время использование аргументов запроса для сопоставления URL недоступно.

Добавлена в версии 0.6: return_rule был добавлен.

Добавлена в версии 0.7: query_args был добавлен.

Изменено в версии 0.8: query_args теперь также может быть строкой.

test(path_info=None, method=None)

Проверка, будет ли соответствовать правило. Работает как match но возвращает True если URL соответствует, или False если его нет.

Параметры:	path_info – информация о пути для использования при сопоставлении. Переопределяет информацию о пути, указанную при связывании. method – HTTP-метод, используемый для сопоставления. Переопределяет метод, указанный при связывании.

class werkzeug.routing.Rule(string, defaults=None, subdomain=None, methods=None, build_only=False, endpoint=None, strict_slashes=None, redirect_to=None, alias=False, host=None)

Правило представляет собой один шаблон URL. Существует несколько вариантов Rule, которые изменяют его поведение и передаются в конструктор Rule. Обратите внимание, что помимо строки правила все аргументы должны быть именованными аргументами, чтобы не сломать приложение при обновлении Werkzeug.

string

Строки правил в основном являются обычными URL-путями с плейсхолдерами в формате <converter(arguments):name>, где конвертер и аргументы являются необязательными. Если конвертер не определен, используется конвертер default, что означает string в обычной конфигурации.

URL-правила, заканчивающиеся слешем, являются правилами ветвления, остальные — правилами листьев. Если включён strict_slashes (что является значением по умолчанию), все URL-правила ветвления, которые сопоставляются без заключительного слеша, вызовут переадресацию на тот же URL с добавленным недостающим слешем.

Конвертеры определены в Map.

endpoint

Конечная точка (endpoint) для этого правила. Это может быть что угодно: ссылка на функцию, строка, число и т.д. Предпочтительным способом является использование строки, поскольку конечная точка используется для генерации URL.

defaults

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

url_map = Map([
    Rule('/all/', defaults={'page': 1}, endpoint='all_entries'),
    Rule('/all/page/<int:page>', endpoint='all_entries')
])

Если пользователь теперь посетит http://example.com/all/page/1, он будет перенаправлен на http://example.com/all/. Если redirect_defaults отключено в экземпляре Map, это повлияет только на генерацию URL.

subdomain

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

Может быть полезно, если вы хотите иметь профили пользователей на разных поддоменах и все поддомены перенаправляются в ваше приложение:

url_map = Map([
    Rule('/', subdomain='<username>', endpoint='user/homepage'),
    Rule('/stats', subdomain='<username>', endpoint='user/stats')
])

methods

Последовательность HTTP-методов, к которым применяется это правило. Если не указано, разрешены все методы. Например, это может быть полезно, если вы хотите разные конечные точки для POST и GET. Если методы определены и путь совпадает, но метод, по которому произошло сопоставление, отсутствует в этом списке или в списке другого правила для этого пути, возникающая ошибка имеет тип MethodNotAllowed, а не NotFound. Если GET присутствует в списке методов, а HEAD отсутствует, HEAD добавляется автоматически.

Изменено в версии 0.6.1: HEAD теперь автоматически добавляется в список методов, если GET присутствует. Причина в том, что существующий код часто не работал должным образом на серверах, не переписывающих HEAD в GET автоматически, и не было документировано, как HEAD должен обрабатываться. Это считалось ошибкой в Werkzeug по этой причине.

strict_slashes

Переопределяет значение Map для strict_slashes только для этого правила. Если не указано, используется значение Map.

build_only

Установите это значение в True, и правило никогда не будет сопоставляться, но будет создан URL, который можно построить. Это полезно, если у вас есть ресурсы на поддомене или в папке, которые не обрабатываются приложением WSGI (например, статические данные).

redirect_to

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

def foo_with_slug(adapter, id):
    # ask the database for the slug for the old id.  this of
    # course has nothing to do with werkzeug.
    return 'foo/' + Foo.get_slug_for_id(id)

url_map = Map([
    Rule('/foo/<slug>', endpoint='foo'),
    Rule('/some/old/url/<slug>', redirect_to='foo/<slug>'),
    Rule('/other/old/url/<int:id>', redirect_to=foo_with_slug)
])

Когда правило сопоставляется, система маршрутизации вызовет исключение RequestRedirect с целевым URL для перенаправления.

Помните, что URL будет соединён с корнем URL скрипта, поэтому не используйте начальный слэш в целевом URL, если вы не имеете в виду корень этого домена.

alias

Если включено, это правило служит псевдонимом для другого правила с той же конечной точкой и аргументами.

host

Если указано и в URL-карте включено сопоставление по хосту, это может использоваться для предоставления правила соответствия для всего хоста. Это также означает, что функция поддомена отключена.

Добавлено в версии 0.7: Параметры alias и host были добавлены.

empty()

Возвращает не связанную копию этого правила.

Это может быть полезно, если вы хотите повторно использовать уже связанный URL для другой карты. См. get_empty_kwargs для переопределения того, какие именованные аргументы предоставляются новой копии.

Производящие правила

class werkzeug.routing.RuleFactory

Как только у вас появятся более сложные настройки URL, рекомендуется использовать фабрики правил, чтобы избежать повторяющихся задач. Некоторые из них встроенные, другие можно добавить, наследовавшись от RuleFactory и переопределением get_rules.

get_rules(map)

Подклассы RuleFactory должны переопределить этот метод и вернуть итерируемый объект правил.

class werkzeug.routing.Subdomain(subdomain, rules)

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

url_map = Map([
    Rule('/', endpoint='#select_language'),
    Subdomain('<string(length=2):lang_code>', [
        Rule('/', endpoint='index'),
        Rule('/about', endpoint='about'),
        Rule('/help', endpoint='help')
    ])
])

Все правила, кроме конечной точки '#select_language', теперь будут прослушивать поддомен длиной в две буквы, содержащий код языка текущего запроса.

class werkzeug.routing.Submount(path, rules)

Подобно Subdomain, но префикс URL-правила заданной строкой:

url_map = Map([
    Rule('/', endpoint='index'),
    Submount('/blog', [
        Rule('/', endpoint='blog/index'),
        Rule('/entry/<entry_slug>', endpoint='blog/show')
    ])
])

Теперь правило 'blog/show' соответствует /blog/entry/<entry_slug>.

class werkzeug.routing.EndpointPrefix(prefix, rules)

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

url_map = Map([
    Rule('/', endpoint='index'),
    EndpointPrefix('blog/', [Submount('/blog', [
        Rule('/', endpoint='index'),
        Rule('/entry/<entry_slug>', endpoint='show')
    ])])
])

Шаблоны правил

class werkzeug.routing.RuleTemplate(rules)

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

Вот небольшой пример такого шаблона правила:

from werkzeug.routing import Map, Rule, RuleTemplate

resource = RuleTemplate([
    Rule('/$name/', endpoint='$name.list'),
    Rule('/$name/<int:id>', endpoint='$name.show')
])

url_map = Map([resource(name='user'), resource(name='page')])

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

Пользовательские конвертеры

Вы можете добавить пользовательские конвертеры, которые добавляют поведение, не предоставляемое встроенными конвертерами. Для создания пользовательского конвертера необходимо унаследовать от BaseConverter, а затем передать новый класс в параметр Map converters или добавить его в url_map.converters.

Конвертер должен иметь атрибут regex с регулярным выражением для сопоставления. Если конвертер может принимать аргументы в правиле URL, он должен принимать их в методе __init__.

Он может реализовать метод to_python для преобразования сопоставленной строки в другой объект. Это также может выполнить дополнительную проверку, которая не была возможна с атрибутом regex, и в этом случае должно генерировать исключение werkzeug.routing.ValidationError. Генерация других ошибок приведёт к ошибке 500.

Он может реализовать метод to_url для преобразования объекта Python в строку при построении URL. Любая ошибка, сгенерированная здесь, будет преобразована в werkzeug.routing.BuildError и в конечном итоге приведёт к ошибке 500.

Этот пример реализует конвертер BooleanConverter, который будет сопоставлять строки "yes", "no", и "maybe", возвращая случайное значение для "maybe".

from random import randrange
from werkzeug.routing import BaseConverter, ValidationError

class BooleanConverter(BaseConverter):
    regex = r"(?:yes|no|maybe)"

    def __init__(self, url_map, maybe=False):
        super(BooleanConverter, self).__init__(url_map)
        self.maybe = maybe

    def to_python(self, value):
        if value == "maybe":
            if self.maybe:
                return not randrange(2)
            raise ValidationError
        return value == 'yes'

    def to_url(self, value):
        return "yes" if value else "no"

from werkzeug.routing import Map, Rule

url_map = Map([
    Rule("/vote/<bool:werkzeug_rocks>", endpoint="vote"),
    Rule("/guess/<bool(maybe=True):foo>", endpoint="guess")
], converters={'bool': BooleanConverter})

Если вы хотите изменить конвертер по умолчанию, назначьте другой конвертер ключу "default".

Сопоставление по хосту

Начиная с Werkzeug 0.7, также возможно выполнять сопоставление по полному имени хоста, а не только по поддомену. Для включения этой функции необходимо передать host_matching=True в конструктор Map и указать аргумент host для всех маршрутов:

url_map = Map([
    Rule('/', endpoint='www_index', host='www.example.com'),
    Rule('/', endpoint='help_index', host='help.example.com')
], host_matching=True)

Конечно, переменные части также возможны в разделе хоста:

url_map = Map([
    Rule('/', endpoint='www_index', host='www.example.com'),
    Rule('/', endpoint='user_index', host='<user>.example.com')
], host_matching=True)