U
|
Þ=®d ã @ s¬ d dl mZ d dlZd dlZd dlmZ d dlmZ d dl m
|
Z
|
d dl m Z d dl m Z dd l mZ dd
|
l mZ dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddl$m%Z% dd l&m'Z' dd l&m(Z( ej)rd d l*m+Z+ d d l*m,Z, dd l m-Z- dd!l&m.Z. dd"l/m0Z0 G d#d$ d$Z1G d%d& d&Z2dS )'é )Ú annotationsN)Úpformat)ÚLock)Úquote)Úurljoin)Ú
|
urlunsplité )Ú _get_environ)Ú_wsgi_decoding_dance)Ú ImmutableDict)Ú MultiDict)ÚBadHost)Ú HTTPException)ÚMethodNotAllowed)ÚNotFound)Ú
|
_urlencode)Úget_hosté )ÚDEFAULT_CONVERTERS)Ú
|
BuildError)ÚNoMatch)ÚRequestAliasRedirect)Ú RequestPath)ÚRequestRedirect)ÚWebsocketMismatch)ÚStateMachineMatcher)Ú_simple_rule_re)ÚRule)ÚWSGIApplication)ÚWSGIEnvironment)Ú BaseConverter)Ú RuleFactory)ÚRequestc @ sØ e Zd ZdZeeZeZd.dddd d d d
|
d d dd d d ddZ ddd dddZ
|
e ddddZ d/dddddZ dd d d d Zd0ddddddd!d"d#d$d%Zd1d&ddd"d'd(d)Zd dd*d+Zddd,d-ZdS )2ÚMapa_ The map class stores all the URL rules and some configuration
|
parameters. Some of the configuration values are only stored on the
|
`Map` instance since those affect all rules, others are just defaults
|
and can be overridden for each rule. Note that you have to specify all
|
arguments besides the `rules` as keyword arguments!
|
|
:param rules: sequence of url rules for this map.
|
:param default_subdomain: The default subdomain for rules without a
|
subdomain defined.
|
:param charset: charset of the url. defaults to ``"utf-8"``
|
:param strict_slashes: If a rule ends with a slash but the matched
|
URL does not, redirect to the URL with a trailing slash.
|
:param merge_slashes: Merge consecutive slashes when matching or
|
building URLs. Matches will redirect to the normalized URL.
|
Slashes in variable parts are not merged.
|
:param redirect_defaults: This will redirect to the default rule if it
|
wasn't visited that way. This helps creating
|
unique URLs.
|
:param converters: A dict of converters that adds additional converters
|
to the list of converters. If you redefine one
|
converter this will override the original one.
|
:param sort_parameters: If set to `True` the url parameters are sorted.
|
See `url_encode` for more details.
|
:param sort_key: The sort key function for `url_encode`.
|
:param encoding_errors: the error method to use for decoding
|
:param host_matching: if set to `True` it enables the host matching
|
feature and disables the subdomain one. If
|
enabled the `host` parameter to rules is used
|
instead of the `subdomain` one.
|
|
.. versionchanged:: 2.3
|
The ``charset`` and ``encoding_errors`` parameters are deprecated and will be
|
removed in Werkzeug 3.0.
|
|
.. versionchanged:: 1.0
|
If ``url_scheme`` is ``ws`` or ``wss``, only WebSocket rules will match.
|
|
.. versionchanged:: 1.0
|
The ``merge_slashes`` parameter was added.
|
|
.. versionchanged:: 0.7
|
The ``encoding_errors`` and ``host_matching`` parameters were added.
|
|
.. versionchanged:: 0.5
|
The ``sort_parameters`` and ``sort_key`` paramters were added.
|
NÚ TFz t.Iterable[RuleFactory] | NoneÚstrú
|
str | NoneÚboolz*t.Mapping[str, type[BaseConverter]] | Nonez!t.Callable[[t.Any], t.Any] | NoneÚNone) ÚrulesÚdefault_subdomainÚcharsetÚstrict_slashesÚ merge_slashesÚredirect_defaultsÚ
|
convertersÚsort_parametersÚsort_keyÚencoding_errorsÚ host_matchingÚreturnc C sÊ t || _i | _d| _| ¡ | _|| _|d k r@tjdt dd nd}|| _
|
|
|
d k rdtjdt dd nd}
|
|
|
| _ || _ || _ || _| | _| j ¡ | _|r¢| j |¡ || _| | _|p´dD ]} | | ¡ q¶d S ) NTzJThe 'charset' parameter is deprecated and will be removed in Werkzeug 3.0.r ©Ú
|
stacklevelzutf-8zRThe 'encoding_errors' parameter is deprecated and will be removed in Werkzeug 3.0.Úreplace© )r Ú_matcherÚ_rules_by_endpointÚ_remapÚ
|
lock_classÚ _remap_lockr* ÚwarningsÚwarnÚDeprecationWarningr+ r2 r, r- r. r3 Údefault_convertersÚcopyr/ Úupdater0 r1 Úadd) Úselfr) r* r+ r, r- r. r/ r0 r1 r2 r3 Ú rulefactoryr8 r8 úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/routing/map.pyÚ__init__` s@
|
|
üü z Map.__init__)ÚendpointÚ argumentsr4 c G s6 | ¡ t|}| j| D ]}| |j¡r dS qdS )aQ Iterate over all rules and check if the endpoint expects
|
the arguments provided. This is for example useful if you have
|
some URLs that expect a language code and others that do not and
|
you want to wrap the builder a bit so that the current language
|
code is automatically added if not provided but endpoints expect
|
it.
|
|
:param endpoint: the endpoint to check.
|
:param arguments: this function accepts one or more arguments
|
as positional arguments. Each one of them is
|
checked.
|
TF)rC Úsetr: ÚissubsetrJ )rE rI rJ Úruler8 r8 rG Úis_endpoint_expecting s zMap.is_endpoint_expectingz
|
list[Rule])r4 c C s dd | j ¡ D S )Nc S s g | ]}|D ]}|q qS r8 r8 )Ú.0r) rM r8 r8 rG Ú
|
<listcomp>± s z Map._rules.<locals>.<listcomp>)r: Úvalues)rE r8 r8 rG Ú_rules¯ s z
|
Map._ruleszt.Iterator[Rule])rI r4 c C s( | ¡ |dk r t| j| S t| jS )zÇIterate over all rules or the rules of an endpoint.
|
|
:param endpoint: if provided only the rules for that endpoint
|
are returned.
|
:return: an iterator
|
N)rC Úiterr: rR )rE rI r8 r8 rG Ú
|
iter_rules³ s zMap.iter_rulesr! )rF r4 c C sL | | ¡D ]6}| | ¡ |js*| j |¡ | j |jg ¡ |¡ q
|
d| _ dS )z¼Add a new rule or factory to the map and bind it. Requires that the
|
rule is not bound to another map.
|
|
:param rulefactory: a :class:`Rule` or :class:`RuleFactory`
|
TN)
|
Z get_rulesÚbindZ
|
build_onlyr9 rD r: Ú
|
setdefaultrI Úappendr; )rE rF rM r8 r8 rG rD ¿ s
|
zMap.addÚhttpÚGETú"t.Mapping[str, t.Any] | str | NoneÚ
|
MapAdapter)Ú server_nameÚ script_nameÚ subdomainÚ
|
url_schemeÚdefault_methodÚ path_infoÚ
|
query_argsr4 c
|
C s¸ | ¡ }| jr |dk r.tdn|dkr.| j}|dkr:d}|dkrFd}| d¡\}}} z| d¡ d¡}W n* tk
|
r }
|
z t |
|
W 5 d}
|
~
|
X Y nX t | | | | ||||||S )a Return a new :class:`MapAdapter` with the details specified to the
|
call. Note that `script_name` will default to ``'/'`` if not further
|
specified or `None`. The `server_name` at least is a requirement
|
because the HTTP RFC requires absolute URLs for redirects and so all
|
redirect exceptions raised by Werkzeug will contain the full canonical
|
URL.
|
|
If no path_info is passed to :meth:`match` it will use the default path
|
info passed to bind. While this doesn't really make sense for
|
manual bind calls, it's useful if you bind a map to a WSGI
|
environment which already contains the path info.
|
|
`subdomain` will default to the `default_subdomain` for this map if
|
no defined. If there is no `default_subdomain` you cannot use the
|
subdomain feature.
|
|
.. versionchanged:: 1.0
|
If ``url_scheme`` is ``ws`` or ``wss``, only WebSocket rules
|
will match.
|
|
.. versionchanged:: 0.15
|
``path_info`` defaults to ``'/'`` if ``None``.
|
|
.. versionchanged:: 0.8
|
``query_args`` can be a string.
|
|
.. versionchanged:: 0.7
|
Added ``query_args``.
|
Nz2host matching enabled and a subdomain was providedú/ú:ÚidnaÚascii)
|
Úlowerr3 Ú RuntimeErrorr* Ú partitionÚencodeÚdecodeÚ UnicodeErrorr r[ ) rE r\ r] r^ r_ r` ra rb Zport_sepÚportÚer8 r8 rG rU Ì s2 '
|
øzMap.bindzWSGIEnvironment | Request)Úenvironr\ r^ r4 c
|
s t | t ¡ } d }tdd dd¡ ¡ d¡D }|rh dd¡ ¡ dkrh|d krdd
|
nd }|d krv|}nF| ¡ }|d kr| d¡r|d d
}n |dkr¼| d¡r¼|d d
}|d kr6js6| d¡}| d¡}t| } || d
|kr t j
|
d|d|dd d}nd t d |d |
¡}ddd fd d }
|
|
|
d } |
|
d } |
|
d } t j|| || d! | | d"S )#aÄ Like :meth:`bind` but you can pass it an WSGI environment and it
|
will fetch the information from that dictionary. Note that because of
|
limitations in the protocol there is no way to get the current
|
subdomain and real `server_name` from the environment. If you don't
|
provide it, Werkzeug will use `SERVER_NAME` and `SERVER_PORT` (or
|
`HTTP_HOST` if provided) as used `server_name` with disabled subdomain
|
feature.
|
|
If `subdomain` is `None` but an environment and a server name is
|
provided it will calculate the current subdomain automatically.
|
Example: `server_name` is ``'example.com'`` and the `SERVER_NAME`
|
in the wsgi `environ` is ``'staging.dev.example.com'`` the calculated
|
subdomain will be ``'staging.dev'``.
|
|
If the object passed as environ has an environ attribute, the value of
|
this attribute is used instead. This allows you to pass request
|
objects. Additionally `PATH_INFO` added as a default of the
|
:class:`MapAdapter` so that you don't have to pass the path info to
|
the match method.
|
|
.. versionchanged:: 1.0.0
|
If the passed server name specifies port 443, it will match
|
if the incoming scheme is ``https`` without a port.
|
|
.. versionchanged:: 1.0.0
|
A warning is shown when the passed server name does not
|
match the incoming WSGI server name.
|
|
.. versionchanged:: 0.8
|
This will no longer raise a ValueError when an unexpected server
|
name was passed.
|
|
.. versionchanged:: 0.5
|
previously this method accepted a bogus `calculate_subdomain`
|
parameter that did not have any effect. It was removed because
|
of that.
|
|
:param environ: a WSGI environment.
|
:param server_name: an optional server name hint (see above).
|
:param subdomain: optionally the current subdomain (see above).
|
zwsgi.url_schemec s s | ]}| ¡ d kV qdS )ÚupgradeN)Ústrip)rO Úvr8 r8 rG Ú <genexpr>C s ÿz&Map.bind_to_environ.<locals>.<genexpr>ZHTTP_CONNECTIONr$ ú,Z HTTP_UPGRADEÚ websocketÚhttpsÚwssÚwsN> rX rx z:80éýÿÿÿ> rv rw z:443éüÿÿÿÚ.zCurrent server name z& doesn't match configured server name r r5 z <invalid>r% r& )Únamer4 c s" | ¡}|d k r t|jS d S ©N)Úgetr
|
r+ )r| Úval©ÚenvrE r8 rG Ú_get_wsgi_stringj s
|
z-Map.bind_to_environ.<locals>._get_wsgi_stringZ SCRIPT_NAMEZ PATH_INFOÚ QUERY_STRINGÚREQUEST_METHOD)rb )r r rg Úanyr~ ÚsplitÚendswithr3 Úlenr> r? ÚjoinÚfilterr# rU )rE ro r\ r^ Zwsgi_server_nameÚschemerp Zcur_server_nameZreal_server_nameÚoffsetr r] ra rb r8 r rG Úbind_to_environ sP / þ
|
|
|
ýøzMap.bind_to_environc C sd | j s
|
dS | jJ | j s&W 5 Q R £ dS | j ¡ | j ¡ D ]}|jdd d q:d| _ W 5 Q R X dS )zzCalled before matching and building to keep the compiled rules
|
in the correct order after things changed.
|
Nc S s | ¡ S r} )Zbuild_compare_key)Úxr8 r8 rG Ú<lambda> ó z Map.update.<locals>.<lambda>)ÚkeyF)r; r= r9 rC r: rQ Úsort©rE r) r8 r8 rG rC ~ s
|
z
|
Map.updatec C s& | ¡ }t| j dtt| dS )Nú(ú))rT ÚtypeÚ__name__r Úlistr r8 r8 rG Ú__repr__ s z Map.__repr__) Nr$ NTTTNFNNF)N)NNrX rY NN)NN)r Ú
|
__module__Ú __qualname__Ú__doc__r r rA r r< rH rN ÚpropertyrR rT rD rU r rC r r8 r8 r8 rG r# ( s@ 0 ô&; ø H ümr# c
|
@ s\ e Zd ZdZd?ddddddddddd Zd@d ddd d dddZejdAdddddddddZejdBdddddddddZdCddd ddddd dZdDddd d d d Z dEdd d!d"d#Z
|
ddd$d%d&Z d'dd(d)dd*d+d,Z d)dd-d.d/Z dFddddd0d1d2Zddd3dd)dd4d5d6Zdd3dd d7d8d9d:ZdGdd;dd d ddd<d=d>ZdS )Hr[ zReturned by :meth:`Map.bind` or :meth:`Map.bind_to_environ` and does
|
the URL matching and building based on runtime information.
|
Nr# r% r& rZ )Úmapr\ r] r^ r_ ra r` rb c C sR || _ || _| d¡s |d7 }|| _|| _|| _|| _|| _|| _| jdk| _ d S )Nrc > rw rx )
|
r r\ r r] r^ r_ ra r` rb ru ) rE r r\ r] r^ r_ ra r` rb r8 r8 rG rH s
|
zMapAdapter.__init__Fz9t.Callable[[str, t.Mapping[str, t.Any]], WSGIApplication]r' r )Ú view_funcra ÚmethodÚcatch_http_exceptionsr4 c
|
C s zNz| ||¡\}}W n, tk
|
rB } z| W Y ¢W S d}~X Y nX |||W S tk
|
r } z|rp| W Y ¢S W 5 d}~X Y nX dS )a3 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 :class:`Response.force_type` to get a response object.
|
|
:param view_func: 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)
|
:param path_info: the path info to use for matching. Overrides the
|
path info specified on binding.
|
:param method: the HTTP method used for matching. Overrides the
|
method specified on binding.
|
:param catch_http_exceptions: set to `True` to catch any of the
|
werkzeug :class:`HTTPException`\s.
|
N©Úmatchr r )rE r ra r r¡ rI Úargsrn r8 r8 rG Údispatch² s 1 zMapAdapter.dispatchzt.Literal[False]z bool | Nonez!tuple[str, t.Mapping[str, t.Any]])ra r Ú return_rulerb ru r4 c C s d S r} r8 ©rE ra r r¦ rb ru r8 r8 rG r£ î s zMapAdapter.matchTzt.Literal[True]z"tuple[Rule, t.Mapping[str, t.Any]]c C s d S r} r8 r§ r8 r8 rG r£ ù s z(tuple[str | Rule, t.Mapping[str, t.Any]]c sd | j ¡ |dkr| j}|dkr*| jp(i }|p2| j ¡ }|dkrF| j}| j}| j jsd| j dk rd| j }|rxd|
|
d¡ nd}z| j j ||||¡}W nè t k
|
rÞ } z*t| jd| j jd}
|
t| |
|
|¡dW 5 d} ~ X Y n tk
|
r( } z*t| | d| | j| j||¡dW 5 d} ~ X Y n8 tk
|
r| } z6| jrTtt| jdd| jrdt dt dW 5 d} ~ X Y näX |\ | j j r²| ||¡} | dk r²t| j dk rHt j t!ròdd d
|
fd d } t" #| j ¡} n j | f} | j r | j d | j } n| j} tt$| j%p0d d| | j& | |rV fS jfS dS )aà 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
|
|
:param path_info: the path info to use for matching. Overrides the
|
path info specified on binding.
|
:param method: the HTTP method used for matching. Overrides the
|
method specified on binding.
|
:param return_rule: return the rule that matched instead of just the
|
endpoint (defaults to `False`).
|
:param query_args: 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.
|
:param websocket: Match WebSocket instead of HTTP requests. A
|
websocket request has a ``ws`` or ``wss``
|
:attr:`url_scheme`. This overrides that detection.
|
|
.. versionadded:: 1.0
|
Added ``websocket``.
|
|
.. versionchanged:: 0.8
|
``query_args`` can be a string.
|
|
.. versionadded:: 0.7
|
Added ``query_args``.
|
|
.. versionadded:: 0.6
|
Added ``return_rule``.
|
Nrc r$ z!$&'()*+,/:;=@)ÚsafeÚencodingú|)Ú valid_methodsz t.Match[str]r% )r£ r4 c s$ | d¡ } j| d¡ |¡S )Nr )ÚgroupÚ _convertersZto_url)r£ Úvalue©rM Úrvr8 rG Ú _handle_match s z'MapAdapter.match.<locals>._handle_matchr{ rX z://)'r rC ra rb r` Úupperru r\ r3 r^ Úlstripr9 r£ r r r+ r Úmake_redirect_urlr Úmake_alias_redirect_urlrI Zmatched_valuesr Zhave_match_forr r Zwebsocket_mismatchr r r. Úget_default_redirectZ redirect_toÚ
|
isinstancer% r Úsubr r_ r] )rE ra r r¦ rb ru Ú domain_partZ path_partÚresultrn Únew_pathZ redirect_urlr± Únetlocr8 r¯ rG r£ s _
|
|
ÿ
|
ÿþ ûÿø
|
|
þÿ)ra r r4 c C s> z| ||¡ W n( tk
|
r$ Y n tk
|
r8 Y dS X dS )a Test if a rule would match. Works like `match` but returns `True`
|
if the URL matches, or `False` if it does not exist.
|
|
:param path_info: the path info to use for matching. Overrides the
|
path info specified on binding.
|
:param method: the HTTP method used for matching. Overrides the
|
method specified on binding.
|
FTr¢ )rE ra r r8 r8 rG Útest´ s zMapAdapter.testzt.Iterable[str])ra r4 c
|
C sV z| j |dd W n> tk
|
r> } z|j W Y ¢S d}~X Y n tk
|
rP Y nX g S )z^Returns the valid methods that match for a given path.
|
|
.. versionadded:: 0.7
|
z--)r N)r£ r r« r )rE ra rn r8 r8 rG Úallowed_methodsÅ s zMapAdapter.allowed_methods)r¹ r4 c C sL | j jr|dkr| jS |S |dkr*| j}n|}|rB| d| j S | jS dS )z©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.
|
Nr{ )r r3 r\ r^ )rE r¹ r^ r8 r8 rG r Ò s zMapAdapter.get_hostr z t.MutableMapping[str, t.Any]zt.Mapping[str, t.Any] | str)rM r rQ rb r4 c C st | j js t| j j|j D ]T}||kr* qp| |¡r| ||¡r| |j¡ | |¡\}}| j
|
|||d S qdS )zA helper that returns the URL to redirect to if it finds one.
|
This is used for default redirecting only.
|
|
:internal:
|
)r¹ N) r r. ÚAssertionErrorr: rI Zprovides_defaults_forÚ suitable_forrC ÚdefaultsÚbuildr´ )rE rM r rQ rb Úrr¹ Úpathr8 r8 rG r¶ ç s z MapAdapter.get_default_redirect)rb r4 c C s t |tst|| jjdS |S )N)r© )r· r% r r r+ )rE rb r8 r8 rG Úencode_query_args s
|
z MapAdapter.encode_query_args)ra rb r¹ r4 c C sd |dkr| j }|r | |¡}nd}| jp*d}| |¡}d | j d¡| d¡f¡}t||||dfS )z4Creates a redirect URL.
|
|
:internal:
|
NrX rc ) rb rÅ r_ r r r] rq r³ r )rE ra rb r¹ Z query_strr ÚhostrÄ r8 r8 rG r´ s
|
|
|
z MapAdapter.make_redirect_urlzt.Mapping[str, t.Any])rÄ rI rQ r rb r4 c C s@ | j |||ddd}|r,|d| |¡ 7 }||ks<td|S )z0Internally called to make an alias redirect URL.FT)Úappend_unknownÚforce_externalú?z6detected invalid alias setting. No canonical URL found)r rÅ r¿ )rE rÄ rI rQ r rb Úurlr8 r8 rG rµ s ÿz"MapAdapter.make_alias_redirect_urlz tuple[str, str, bool] | None)rI rQ r rÇ r4 c C s¬ |dkr&| ||| j|¡}|dk r&|S d}| jj |d¡D ]l}| ||¡r:| ||¡}|dk r:|d |d |jf}| jjr|d | j kr| S |dkr¦|}q:| S q:|S )zHelper for :meth:`build`. Returns subdomain and path for the
|
rule that accepts this endpoint, values and method.
|
|
:internal:
|
Nr8 r r )
|
Ú_partial_buildr` r r: r~ rÀ r ru r3 r\ ) rE rI rQ r rÇ r° Z first_matchrM Zbuild_rvr8 r8 rG rË - s, ÿ
|
zMapAdapter._partial_buildz t.Mapping[str, t.Any] | None)rI rQ r rÈ rÇ r_ r4 c C sB | j ¡ |rBt|tr.dd t |¡D }qFdd | ¡ D }ni }| ||||¡}|dkrlt|||| |\}} }
|
| |¡} |dkr| j }|dk} |
|
r¬d}| r¦dnd}n|r¼| r¸d nd
|
}|s| j j
|
rÔ| | j ksê| j j
|
s|| j kr| j d ¡ d | d ¡ S |r| d nd } | d| | j dd
d | d ¡ S )a; 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
|
:py:class:`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.
|
|
:param endpoint: the endpoint of the URL to build.
|
:param values: the values for the URL to build. Unhandled values are
|
appended to the URL as query parameters.
|
:param method: the HTTP method for the rule if there are different
|
URLs for different methods on the same endpoint.
|
:param force_external: enforce full canonical external URLs. If the URL
|
scheme is not provided, this will generate
|
a protocol-relative URL.
|
:param append_unknown: unknown parameters are appended to the generated
|
URL as query string argument. Disable this
|
if you want the builder to ignore those.
|
:param url_scheme: Scheme to use in place of the bound
|
:attr:`url_scheme`.
|
|
.. versionchanged:: 2.0
|
Added the ``url_scheme`` parameter.
|
|
.. versionadded:: 0.6
|
Added the ``append_unknown`` parameter.
|
c S s6 i | ].\}}t |d kr|t |dkr.|d n|qS )r r )r ©rO Úkrr r8 r8 rG Ú
|
<dictcomp>ª s þ z$MapAdapter.build.<locals>.<dictcomp>c S s i | ]\}}|d k r||qS r} r8 rÌ r8 r8 rG rÎ ° s N> rv rw Trw rx rv rX rc rd r$ z//éÿÿÿÿ)r rC r· r ÚdictÚitemsrË r r r_ r3 r\ r^ r] Úrstripr³ )rE rI rQ r rÈ rÇ r_ r° r¹ rÄ ru rÆ Úsecurer r8 r8 rG r V sB P
|
|
þ
|
|
ÿÿþþ zMapAdapter.build)N)NNF)NNFNN)NNTNN)NNFNN)NN)N)NN)NNFTN)r r r r rH r¥ ÚtÚoverloadr£ r½ r¾ r r¶ rÅ r´ rµ rË r r8 r8 r8 rG r[ sX ÷ û< ú
|
ú ú 1 ü, ùr[ )3Ú
|
__future__r ÚtypingrÔ r> Úpprintr Ú threadingr Ú urllib.parser r r Ú _internalr r
|
Zdatastructuresr r Ú
|
exceptionsr r r r Úurlsr Zwsgir r/ r r r r r r r Zmatcherr r) r r Ú TYPE_CHECKINGZ_typeshed.wsgir r r r! Zwrappers.requestr" r# r[ r8 r8 r8 rG Ú<module> sJ m
|
