class werkzeug.routing.MapAdapter(map, server_name, script_name, subdomain, url_scheme, path_info, default_method, query_args=None)  
Returned by Map.bind() or Map.bind_to_environ() and does the URL matching and building based on runtime information.  Parameters 
 
map (werkzeug.routing.Map) –  
server_name (str) –  
script_name (str) –  
subdomain (Optional[str]) –  
url_scheme (str) –  
path_info (str) –  
default_method (str) –  
query_args (Optional[Union[Mapping[str, Any], str]]) –      
allowed_methods(path_info=None)  
Returns the valid methods that match for a given path.  Changelog New in version 0.7.   Parameters 
path_info (Optional[str]) –   Return type 
Iterable[str]   
  
build(endpoint, values=None, method=None, force_external=False, append_unknown=True, url_scheme=None)  
Building URLs works pretty much the other way round. Instead of match you call build and pass it the endpoint and a dict of arguments for the placeholders. The build function also accepts an argument called force_external which, if you set it to True will force external URLs. Per default external URLs (include the server name) will only be used if the target URL is on a different subdomain. >>> 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'
 Because URLs cannot contain non ASCII data you will always get bytes back. Non ASCII characters are urlencoded with the charset defined on the map instance. Additional values are converted to strings and appended to the URL as URL querystring parameters: >>> urls.build("index", {'q': 'My Searchstring'})
'/?q=My+Searchstring'
 When processing those additional values, lists are furthermore interpreted as multiple values (as per werkzeug.datastructures.MultiDict): >>> urls.build("index", {'q': ['a', 'b', 'c']})
'/?q=a&q=b&q=c'
 Passing a MultiDict will also add multiple values: >>> urls.build("index", MultiDict((('p', 'z'), ('q', 'a'), ('q', 'b'))))
'/?p=z&q=a&q=b'
 If a rule does not exist when building a BuildError exception is raised. The build method accepts an argument called method which allows you to specify the method you want to have an URL built for if you have different methods for the same endpoint specified.  Parameters 
 
endpoint (str) – the endpoint of the URL to build. 
values (Optional[Mapping[str, Any]]) – the values for the URL to build. Unhandled values are appended to the URL as query parameters. 
method (Optional[str]) – the HTTP method for the rule if there are different URLs for different methods on the same endpoint. 
force_external (bool) – enforce full canonical external URLs. If the URL scheme is not provided, this will generate a protocol-relative URL. 
append_unknown (bool) – unknown parameters are appended to the generated URL as query string argument. Disable this if you want the builder to ignore those. 
url_scheme (Optional[str]) – Scheme to use in place of the bound url_scheme.   Return type 
str    Changed in version 2.0: Added the url_scheme parameter.   Changelog New in version 0.6: Added the append_unknown parameter.  

  
dispatch(view_func, path_info=None, method=None, catch_http_exceptions=False)  
Does the complete dispatching process. view_func is called with the endpoint and a dict with the values for the view. It should look up the view function, call it, and return a response object or WSGI application. http exceptions are not caught by default so that applications can display nicer error messages by just catching them by hand. If you want to stick with the default error messages you can pass it catch_http_exceptions=True and it will catch the http exceptions. Here a small example for the dispatch usage: 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)
 Keep in mind that this method might return exception objects, too, so use Response.force_type to get a response object.  Parameters 
 
view_func (Callable[[str, Mapping[str, Any]], WSGIApplication]) – a function that is called with the endpoint as first argument and the value dict as second. Has to dispatch to the actual view function with this information. (see above) 
path_info (Optional[str]) – the path info to use for matching. Overrides the path info specified on binding. 
method (Optional[str]) – the HTTP method used for matching. Overrides the method specified on binding. 
catch_http_exceptions (bool) – set to True to catch any of the werkzeug HTTPExceptions.   Return type 
WSGIApplication   
  
get_host(domain_part)  
Figures out the full host name for the given domain part. The domain part is a subdomain in case host matching is disabled or a full host name.  Parameters 
domain_part (Optional[str]) –   Return type 
str   
  
make_alias_redirect_url(path, endpoint, values, method, query_args)  
Internally called to make an alias redirect URL.  Parameters 
 
path (str) –  
endpoint (str) –  
values (Mapping[str, Any]) –  
method (str) –  
query_args (Union[Mapping[str, Any], str]) –    Return type 
str   
  
match(path_info=None, method=None, return_rule=False, query_args=None, websocket=None)  
The usage is simple: you just pass the match method the current path info as well as the method (which defaults to GET). The following things can then happen:  you receive a NotFound exception that indicates that no URL is matching. A NotFound exception is also a WSGI application you can call to get a default page not found page (happens to be the same object as werkzeug.exceptions.NotFound) you receive a MethodNotAllowed exception that indicates that there is a match for this URL but not for the current request method. This is useful for RESTful applications. you receive a RequestRedirect exception with a new_url attribute. This exception is used to notify you about a request Werkzeug requests from your WSGI application. This is for example the case if you request /foo although the correct URL is /foo/ You can use the RequestRedirect instance as response-like object similar to all other subclasses of HTTPException. you receive a WebsocketMismatch exception if the only match is a WebSocket rule but the bind is an HTTP request, or if the match is an HTTP rule but the bind is a WebSocket request. you get a tuple in the form (endpoint, arguments) if there is a match (unless return_rule is True, in which case you get a tuple in the form (rule, arguments))  If the path info is not passed to the match method the default path info of the map is used (defaults to the root URL if not defined explicitly). All of the exceptions raised are subclasses of HTTPException so they can be used as WSGI responses. They will all render generic error or redirect pages. Here is a small example for matching: >>> 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})
 And here is what happens on redirect and missing URLs: >>> 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
  Parameters 
 
path_info (Optional[str]) – the path info to use for matching. Overrides the path info specified on binding. 
method (Optional[str]) – the HTTP method used for matching. Overrides the method specified on binding. 
return_rule (bool) – return the rule that matched instead of just the endpoint (defaults to False). 
query_args (Optional[Union[Mapping[str, Any], str]]) – optional query arguments that are used for automatic redirects as string or dictionary. It’s currently not possible to use the query arguments for URL matching. 
websocket (Optional[bool]) – Match WebSocket instead of HTTP requests. A websocket request has a ws or wss url_scheme. This overrides that detection.   Return type 
Tuple[Union[str, werkzeug.routing.Rule], Mapping[str, Any]]    Changelog New in version 1.0: Added websocket.   Changed in version 0.8: query_args can be a string.   New in version 0.7: Added query_args.   New in version 0.6: Added return_rule.  

  
test(path_info=None, method=None)  
Test if a rule would match. Works like match but returns True if the URL matches, or False if it does not exist.  Parameters 
 
path_info (Optional[str]) – the path info to use for matching. Overrides the path info specified on binding. 
method (Optional[str]) – the HTTP method used for matching. Overrides the method specified on binding.   Return type 
bool