Маршрутизация 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, заканчивающиеся слешем, являются правилами ветвления, остальные — листьями. Если у вас включён strict_slashes (что является значением по умолчанию), все правила ветвления, которые посещаются без заключительного слеша, вызовут перенаправление на тот же 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)

Класс `Map` хранит все правила 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 был добавлен.

Параметры:

конечная_точка – конечная точка URL, которую нужно построить. значения – значения для построения URL. Необработанные значения добавляются к URL в качестве параметров запроса. метод – 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-исключения.

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

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 – информация о пути, используемая для сопоставления. Переопределяет информацию о пути, указанную при связывании. метод – 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 от вашего 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 – информация о пути, используемая для сопоставления. Переопределяет информацию о пути, указанную при связывании. метод – 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 – информация о пути, используемая для сопоставления. Переопределяет информацию о пути, указанную при связывании. метод – 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 с добавленным отсутствующим слешем.

Преобразователи определяются в Map.

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 в качестве именованных аргументов и должен вернуть целевой объект для перенаправления, в противном случае это должна быть строка с плейсхолдерами в синтаксисе правила:

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, если вы не имеете в виду корень этого домена.

alias

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

host

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

Добавлено в версии 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)