U
|
Þ=®d0} ã @ sÀ d dl mZ d dlZd dlZd dlZd dlmZ d dlm Z d dl
|
m Z d dl m Z ddlmZ dd lmZ d
|
d lmZ ejrd
|
d lmZ d
|
d lmZ G dd dejZeG dd dZe dej ¡Z e d¡Z e dej ¡Z ddddZ ddddddd Z!dd d d d Z"dd!d"d#d$Z#G d%d& d&Z$G d'd( d(e$Z%G d)d* d*e$Z&G d+d, d,e$Z'G d-d. d.Z(G d/d0 d0e$Z)dd1d2d3d4Z*d5Z+d6Z,e*e,Z-e*d7e*d8fZ.G d9d: d:e$Z/dS );é )Ú annotationsN)Ú dataclass)ÚTemplate)ÚCodeType)Úquoteé )Úiter_multi_items)Ú
|
_urlencodeé )ÚValidationError)Ú BaseConverter)ÚMapc @ s. e Zd ZU ded< ded< ded< ded< dS ) Ú WeightingÚintZnumber_static_weightszlist[tuple[int, int]]Ústatic_weightsZnumber_argument_weightsz list[int]Úargument_weightsN)Ú__name__Ú
|
__module__Ú __qualname__Ú__annotations__© r r úMd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/routing/rules.pyr s
|
r c @ s: e Zd ZU dZded< ded< ded< ded< ded < d
|
S ) ÚRuleParta$ A part of a rule.
|
|
Rules can be represented by parts as delimited by `/` with
|
instances of this class representing those parts. The *content* is
|
either the raw content if *static* or a regex string to match
|
against. The *weight* can be used to order parts when matching.
|
|
ÚstrÚcontentÚboolÚfinalÚstaticÚsuffixedr ÚweightN)r r r Ú__doc__r r r r r r s
|
r a
|
(?:
|
(?P<slash>/) # a slash
|
|
|
(?P<static>[^</]+) # static rule data
|
|
|
(?:
|
<
|
(?:
|
(?P<converter>[a-zA-Z_][a-zA-Z0-9_]*) # converter name
|
(?:\((?P<arguments>.*?)\))? # converter arguments
|
: # variable delimiter
|
)?
|
(?P<variable>[a-zA-Z_][a-zA-Z0-9_]*) # variable name
|
>
|
)
|
)
|
z <([^>]+)>z¼
|
((?P<name>\w+)\s*=\s*)?
|
(?P<value>
|
True|False|
|
\d+.\d+|
|
\d+.|
|
\d+|
|
[\w\d_.]+|
|
[urUR]?(?P<stringval>"[^"]*?"|'[^']*')
|
)\s*,
|
TF)ÚNoneÚTrueÚFalser r )ÚvalueÚtargetÚposÚreturnc C s0 z| ||¡W S tk
|
r* t| Y S X dS )zgFind the *target* in *value* after *pos*.
|
|
Returns the *value* length if *target* isn't found.
|
N)ÚindexÚ
|
ValueErrorÚlen)r$ r% r& r r r Ú_findW s r+ z None | bool | int | float | str)r$ r' c C sz | t krt | S ttfD ](}z|| W S tk
|
r> Y qX q| d d
| dd
krr| d dkrr| dd
} t| S )Nr
|
éÿÿÿÿr z"')Ú_PYTHON_CONSTANTSr Úfloatr) r )r$ Úconvertr r r Ú
|
_pythonizeb s $ r0 z tuple[t.Tuple, dict[str, t.Any]])Úargstrr' c C sx | d7 } g }i }t | ¡D ]P}| d¡}|d kr:| d¡}t|}| d¡sX| |¡ q| d¡}|||< qt||fS )Nú,Z stringvalr$ Úname)Ú_converter_args_reÚfinditerÚgroupr0 ÚappendÚtuple)r1 ÚargsÚkwargsÚitemr$ r3 r r r Úparse_converter_argso s
|
|
|
|
|
r< c @ s e Zd ZdZdddddZdS )Ú RuleFactoryzâAs soon as you have more complex URL setups it's a good idea to use rule
|
factories to avoid repetitive tasks. Some of them are builtin, others can
|
be added by subclassing `RuleFactory` and overriding `get_rules`.
|
r út.Iterable[Rule]©Úmapr' c C s
|
t dS )zaSubclasses of `RuleFactory` have to override this method and return
|
an iterable of rules.N)ÚNotImplementedError©Úselfr@ r r r Ú get_rules s zRuleFactory.get_rulesN)r r r r rD r r r r r= s r= c @ s2 e Zd ZdZddddddZdd d
|
d d Zd S )Ú Subdomaina All URLs provided by this factory have the subdomain set to a
|
specific domain. For example if you want to use the subdomain for
|
the current language this can be a good setup::
|
|
url_map = Map([
|
Rule('/', endpoint='#select_language'),
|
Subdomain('<string(length=2):lang_code>', [
|
Rule('/', endpoint='index'),
|
Rule('/about', endpoint='about'),
|
Rule('/help', endpoint='help')
|
])
|
])
|
|
All the rules except for the ``'#select_language'`` endpoint will now
|
listen on a two letter long subdomain that holds the language code
|
for the current request.
|
r út.Iterable[RuleFactory]r! )Ú subdomainÚrulesr' c C s || _ || _d S ©N)rG rH )rC rG rH r r r Ú__init__¡ s zSubdomain.__init__r út.Iterator[Rule]r? c c s6 | j D ]*}| |¡D ]}| ¡ }| j|_|V qqd S rI )rH rD ÚemptyrG ©rC r@ Ú rulefactoryÚruler r r rD ¥ s
|
|
zSubdomain.get_rulesN©r r r r rJ rD r r r r rE s rE c @ s2 e Zd ZdZddddddZdd d
|
d d Zd S )ÚSubmounta} Like `Subdomain` but prefixes the URL rule with a given string::
|
|
url_map = Map([
|
Rule('/', endpoint='index'),
|
Submount('/blog', [
|
Rule('/', endpoint='blog/index'),
|
Rule('/entry/<entry_slug>', endpoint='blog/show')
|
])
|
])
|
|
Now the rule ``'blog/show'`` matches ``/blog/entry/<entry_slug>``.
|
r rF r! )ÚpathrH r' c C s | d¡| _|| _d S )Nú/)ÚrstriprR rH )rC rR rH r r r rJ » s zSubmount.__init__r rK r? c c s< | j D ]0}| |¡D ] }| ¡ }| j|j |_|V qqd S rI )rH rD rL rR rO rM r r r rD ¿ s
|
|
zSubmount.get_rulesNrP r r r r rQ s rQ c @ s2 e Zd ZdZddddddZdd d
|
d d Zd S )ÚEndpointPrefixa Prefixes all endpoints (which must be strings for this factory) with
|
another string. This can be useful for sub applications::
|
|
url_map = Map([
|
Rule('/', endpoint='index'),
|
EndpointPrefix('blog/', [Submount('/blog', [
|
Rule('/', endpoint='index'),
|
Rule('/entry/<entry_slug>', endpoint='show')
|
])])
|
])
|
r rF r! )ÚprefixrH r' c C s || _ || _d S rI )rV rH )rC rV rH r r r rJ Ô s zEndpointPrefix.__init__r rK r? c c s< | j D ]0}| |¡D ] }| ¡ }| j|j |_|V qqd S rI )rH rD rL rV ÚendpointrM r r r rD Ø s
|
|
zEndpointPrefix.get_rulesNrP r r r r rU Ç s rU c @ s2 e Zd ZdZdddddZdddd d
|
d Zd S ) Ú RuleTemplateaX Returns copies of the rules wrapped and expands string templates in
|
the endpoint, rule, defaults or subdomain sections.
|
|
Here a small example for such a rule template::
|
|
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')])
|
|
When a rule template is called the keyword arguments are used to
|
replace the placeholders in all the string parameters.
|
r> r! )rH r' c C s t || _d S rI )ÚlistrH )rC rH r r r rJ ó s zRuleTemplate.__init__zt.AnyÚRuleTemplateFactory)r9 r: r' c O s t | jt||S rI )rZ rH Údict)rC r9 r: r r r Ú__call__ö s zRuleTemplate.__call__N)r r r r rJ r\ r r r r rX à s rX c @ s2 e Zd ZdZddddddZdd d
|
d d Zd S )rZ zsA factory that fills in template variables into rules. Used by
|
`RuleTemplate` internally.
|
|
:internal:
|
rF zdict[str, t.Any]r! )rH Úcontextr' c C s || _ || _d S rI )rH r] )rC rH r] r r r rJ s z RuleTemplateFactory.__init__r rK r? c
|
c sÎ | j D ]Â}| |¡D ]²}d }}|jr`i }|j ¡ D ]*\}}t|trVt| | j¡}|||< q4|j d k r|t|j | j¡}|j
|
}t|trt| | j¡}t t|j | j¡|||j |j||jV qqd S rI )rH rD ÚdefaultsÚitemsÚ
|
isinstancer r Ú
|
substituter] rG rW ÚRulerO ÚmethodsÚ
|
build_onlyÚstrict_slashes) rC r@ rN rO Z new_defaultsrG Úkeyr$ Z new_endpointr r r rD s.
|
|
|
|
|
ùz RuleTemplateFactory.get_rulesNrP r r r r rZ ú s rZ úast.stmt)Úsrcr' c C sP t | ¡jd }t|t jr"|j}t |¡D ] }t|t jr,d|j |_q,|S )zEast parse and prefix names with `.` to avoid collision with user varsr Ú.) ÚastÚparseÚbodyr` ZExprr$ ÚwalkÚNameÚid)rh ÚtreeÚnoder r r Ú _prefix_names! s rr z#self._converters[{elem!r}].to_url()zpif kwargs:
|
params = self._encode_query_vars(kwargs)
|
q = "?" if params else ""
|
else:
|
q = params = ""
|
ÚqÚparamsc @ sh e Zd ZdZdJddddddd d d
|
dddd d d dZd dddZddddZdddddZd dddZdKddd d d d Z ddd dd d!d"d#Z
|
ddd$d%d&Z dd'd(d)d*Z d dd+d,Z ed-dd.d/d0d1ZdLdd.d3d4d5ZdMddd6d7d8d9Zd dd(d:d;ZdNdddd<d=d>Zd?dd@dAZdBddCdDdEZdZdddFdGZdddHdIZdS )Orb a£ A Rule represents one URL pattern. There are some options for `Rule`
|
that change the way it behaves and are passed to the `Rule` constructor.
|
Note that besides the rule-string all arguments *must* be keyword arguments
|
in order to not break the application on Werkzeug upgrades.
|
|
`string`
|
Rule strings basically are just normal URL paths with placeholders in
|
the format ``<converter(arguments):name>`` where the converter and the
|
arguments are optional. If no converter is defined the `default`
|
converter is used which means `string` in the normal configuration.
|
|
URL rules that end with a slash are branch URLs, others are leaves.
|
If you have `strict_slashes` enabled (which is the default), all
|
branch URLs that are matched without a trailing slash will trigger a
|
redirect to the same URL with the missing slash appended.
|
|
The converters are defined on the `Map`.
|
|
`endpoint`
|
The endpoint for this rule. This can be anything. A reference to a
|
function, a string, a number etc. The preferred way is using a string
|
because the endpoint is used for URL generation.
|
|
`defaults`
|
An optional dict with defaults for other rules with the same endpoint.
|
This is a bit tricky but useful if you want to have unique URLs::
|
|
url_map = Map([
|
Rule('/all/', defaults={'page': 1}, endpoint='all_entries'),
|
Rule('/all/page/<int:page>', endpoint='all_entries')
|
])
|
|
If a user now visits ``http://example.com/all/page/1`` they will be
|
redirected to ``http://example.com/all/``. If `redirect_defaults` is
|
disabled on the `Map` instance this will only affect the URL
|
generation.
|
|
`subdomain`
|
The subdomain rule string for this rule. If not specified the rule
|
only matches for the `default_subdomain` of the map. If the map is
|
not bound to a subdomain this feature is disabled.
|
|
Can be useful if you want to have user profiles on different subdomains
|
and all subdomains are forwarded to your application::
|
|
url_map = Map([
|
Rule('/', subdomain='<username>', endpoint='user/homepage'),
|
Rule('/stats', subdomain='<username>', endpoint='user/stats')
|
])
|
|
`methods`
|
A sequence of http methods this rule applies to. If not specified, all
|
methods are allowed. For example this can be useful if you want different
|
endpoints for `POST` and `GET`. If methods are defined and the path
|
matches but the method matched against is not in this list or in the
|
list of another rule for that path the error raised is of the type
|
`MethodNotAllowed` rather than `NotFound`. If `GET` is present in the
|
list of methods and `HEAD` is not, `HEAD` is added automatically.
|
|
`strict_slashes`
|
Override the `Map` setting for `strict_slashes` only for this rule. If
|
not specified the `Map` setting is used.
|
|
`merge_slashes`
|
Override :attr:`Map.merge_slashes` for this rule.
|
|
`build_only`
|
Set this to True and the rule will never match but will create a URL
|
that can be build. This is useful if you have resources on a subdomain
|
or folder that are not handled by the WSGI application (like static data)
|
|
`redirect_to`
|
If given this must be either a string or callable. In case of a
|
callable it's called with the url adapter that triggered the match and
|
the values of the URL as keyword arguments and has to return the target
|
for the redirect, otherwise it has to be a string with placeholders in
|
rule syntax::
|
|
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 f'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)
|
])
|
|
When the rule is matched the routing system will raise a
|
`RequestRedirect` exception with the target for the redirect.
|
|
Keep in mind that the URL will be joined against the URL root of the
|
script so don't use a leading slash on the target URL unless you
|
really mean root of that domain.
|
|
`alias`
|
If enabled this rule serves as an alias for another rule with the same
|
endpoint and arguments.
|
|
`host`
|
If provided and the URL map has host matching enabled this can be
|
used to provide a match rule for the whole host. This also means
|
that the subdomain feature is disabled.
|
|
`websocket`
|
If ``True``, this rule is only matches for WebSocket (``ws://``,
|
``wss://``) requests. By default, rules will only match for HTTP
|
requests.
|
|
.. versionchanged:: 2.1
|
Percent-encoded newlines (``%0a``), which are decoded by WSGI
|
servers, are considered when routing instead of terminating the
|
match early.
|
|
.. versionadded:: 1.0
|
Added ``websocket``.
|
|
.. versionadded:: 1.0
|
Added ``merge_slashes``.
|
|
.. versionadded:: 0.7
|
Added ``alias`` and ``host``.
|
|
.. versionchanged:: 0.6.1
|
``HEAD`` is added to ``methods`` if ``GET`` is present.
|
NFr z t.Mapping[str, t.Any] | Nonez
|
str | Nonezt.Iterable[str] | Noner z bool | Nonez!str | t.Callable[..., str] | Noner! ) Ústringr^ rG rc rd rW re Ú merge_slashesÚ redirect_toÚaliasÚhostÚ websocketr' c C s
|
| d¡std|| _| d¡ | _| d¡| _d | _|| _|| _|| _ | | _
|
|| _ || _ |
|
| _ | | _|d k rÄt|trtddd |D }d|krªd|krª| d¡ | rÄ|dddh rÄtd || _|| _| | _|rìttt|| _nt | _i | _g | _g | _d S )
|
NrS z$urls must start with a leading slashz&'methods' should be a list of strings.c S s h | ] }| ¡ qS r )Úupper)Ú.0Úxr r r Ú <setcomp>Ü s z Rule.__init__.<locals>.<setcomp>ÚHEADÚGETÚOPTIONSzBWebSocket rules can only use 'GET', 'HEAD', and 'OPTIONS' methods.)Ú
|
startswithr) rO ÚendswithZis_leafÚ is_branchr@ re rv rG ry r^ rd rx rz r` r Ú TypeErrorÚaddrc rW rw ÚsetÚ argumentsÚ _convertersÚ_traceÚ_parts) rC ru r^ rG rc rd rW re rv rw rx ry rz r r r rJ ¹ sB
|
|
|
ÿz Rule.__init__)r' c C s t | | jf| ¡ S )zô
|
Return an unbound copy of this rule.
|
|
This can be useful if want to reuse an already bound URL for another
|
map. See ``get_empty_kwargs`` to override what keyword arguments are
|
provided to the new copy.
|
)ÚtyperO Úget_empty_kwargs©rC r r r rL ó s z
|
Rule.emptyzt.Mapping[str, t.Any]c C s> d}| j rt| j }t|| j| j| j| j| j| j| j| j d S )a
|
Provides kwargs for instantiating empty copy with empty()
|
|
Use this method to provide custom keyword arguments to the subclass of
|
``Rule`` when calling ``some_rule.empty()``. Helpful when the subclass
|
has custom keyword arguments that are needed at instantiation.
|
|
Must return a ``dict`` that will be provided as kwargs to the new
|
instance of ``Rule``, following the initial ``self.rule`` value which
|
is always provided as the first, required positional argument.
|
N) r^ rG rc rd rW re rw rx ry )
|
r^ r[ rG rc rd rW re rw rx ry )rC r^ r r r r ý s
|
÷zRule.get_empty_kwargsr rK r? c c s
|
| V d S rI r rB r r r rD s zRule.get_rulesc C s | j | jdd dS )zqRebinds and refreshes the URL. Call this if you modified the
|
rule in place.
|
|
:internal:
|
T)ÚrebindN)Úbindr@ r r r r Úrefresh s z Rule.refresh)r@ r r' c C sl | j dk r$|s$td| d| j || _ | jdkr<|j| _| jdkrN|j| _| jdkr`|j| _| ¡ dS )z§Bind the url to a map and create a regular expression based on
|
the information from the rule itself and the defaults from the map.
|
|
:internal:
|
Nz url rule z already bound to map )r@ Ú RuntimeErrorre rv rG Zdefault_subdomainÚcompile)rC r@ r r r r r # s
|
|
|
z Rule.bindzt.Tupler )Ú variable_nameÚconverter_namer9 r: r' c C s6 || j jkr td|d| j j| | j f||S )zWLooks up the converter for the given parameter.
|
|
.. versionadded:: 0.9
|
zthe converter z does not exist)r@ Ú
|
convertersÚ LookupError)rC r r r9 r: r r r Ú get_converter4 s zRule.get_converter)Ú
|
query_varsr' c C s0 t |}| jjr t|| jjd}t|| jjdS )N)rf )Úencoding)r r@ Zsort_parametersÚsortedÚsort_keyr Úcharset)rC r r_ r r r Ú_encode_query_varsC s zRule._encode_query_varszt.Iterable[RulePart])rO r' c c sv d}d}g }g }d}d}d}|t |k rðt ||¡} | d krLtd|| ¡ }
|
|
|
d d k r®| t |t |
|
d f¡ | j d|
|
d f¡ ||r|
|
d n t |
|
d ¡7 }|
|
d d k rh|rÊt |¡}d}t |
|
d pÚd\} } |
|
|
|
d |
|
d pöd
|
| | ¡} | | j |
|
d < | j |
|
d ¡ | js(d}|d | d | j d 7 }|d7 }| | j¡ | j d|
|
d f¡ |
|
d d k ræ| j d¡ |r|d7 }nT|s |d7 }tt | |t | |}t|||d|dV d}d}g }g }d}d}| ¡ }q d}|r |d dkr d}|d d
d }|s*|d7 }tt | |t | |}t|||||dV |rrtdddd|dV d S )NÚ TFr zmalformed url rule: r Úvariabler Ú converterÚdefaultz(?P<__werkzeug_ú>ú)r
|
Zslash)FrS rS z\Z©r r r r r r, z
|
(?<!/)(/?))r* Ú_part_reÚmatchr) Ú groupdictr7 r ÚreÚescaper< r r r r Zpart_isolatingÚregexr r r Úend)rC rO r r r r r Zconvertor_numberr& r§ ÚdataZc_argsZc_kwargsZconvobjr r r r r Ú _parse_ruleK s°
|
|
ÿ
|
üû
|
üû ÿzRule._parse_rulec
|
C sì | j dk std| j jr&| jp"d}n
|
| jp.d}g | _g | _i | _|dkrltddddt dg dg dg| _n| j
|
| |¡¡ | j d¡ | j }| jr¦t d d
|
| j ¡}| j
|
| |¡¡ | | d¡ | d¡| _| | d¡ | d¡| _dS ) z.Compiles the regular expression and stores it.Nzrule not boundr FTr r¥ )Fú|z/{2,}?rS )r@ ÚAssertionErrorZ host_matchingry rG r r r r r Úextendr® r7 rO rv r© ÚsubÚ_compile_builderÚ__get__Ú_buildÚ_build_unknown)rC Z domain_rulerO r r r r ¨ s4
|
ûÿ
|
z Rule.compiler z t.Callable[..., tuple[str, str]])Úcoder3 r' c C s i }i }t | || || S rI )Úexec)r· r3 ZglobsZlocsr r r Ú_get_func_codeÊ s zRule._get_func_codeT)Úappend_unknownr' c sZ | j pi g }g }|}| jD ]~\}}|dkr:||kr:|}q |rj|krj| j| | ¡}| d|f¡ q |s| dt|d| jjdf¡ q | d|f¡ q dddd d
|
d d d fdd }||}||} |sÚg }
|
ntg}
|
| t
|
¡ d dddd} |
|
t t | || | gt ¡ ¡¡¡ fdd|| D } dd D } td}d| jd|_|jj t dd ¡¡ | | D ] }|jj t |d ¡¡ q|t dd ¡|j_| D ]}|jj t d ¡¡ q®|
|
|_t d ¡}|g|_t |¡D ]R}d |jkrd |_d |jkr|j|_d |jkr(d!|_ d"|jkrì|j |_ qìt |d#d$}| ||j¡S )%Nr¯ Fz!$&'()*+,/:;=@)Úsafer Tr rg )Úelemr' c S s, t tj| d}t t| t ¡ ¡g|_|S )N)r¼ )rr Ú_CALL_CONVERTER_CODE_FMTÚformatrj rn r ÚLoadr9 )r¼ Úretr r r Ú_convertî s z'Rule._compile_builder.<locals>._convertzlist[tuple[bool, str]]z list[ast.AST])Úopsr' c s fdd| D }|p t d¡g}|d g}|dd
D ]F}t|t jrtt|d t jrtt |d j|j ¡|d< q8| |¡ q8|S )Nc s& g | ] \}}|r |nt |¡qS r )rj ÚConstant©r| Ú
|
is_dynamicr¼ ©rÁ r r Ú
|
<listcomp>ô s ÿz9Rule._compile_builder.<locals>._parts.<locals>.<listcomp>r r r
|
r, )rj rà r` r$ r7 )r ÚpartsrÀ ÚprÆ r r r ó s
|
þ
|
z%Rule._compile_builder.<locals>._partszast.AST)rÈ r' c S s t | dkr| d S t | ¡S )Nr
|
r )r* rj Z JoinedStr)rÈ r r r Ú_join
|
s z$Rule._compile_builder.<locals>._joinc s g | ]\}}|r| kr|qS r r rÄ )r^ r r rÇ s þz)Rule._compile_builder.<locals>.<listcomp>c S s g | ] }t |qS r )r )r| Úkr r r rÇ s z def _(): passz <builder:r£ z.selfz.kwargsr Úlinenor
|
Ú
|
end_linenoÚ
|
col_offsetr Úend_col_offsetz<werkzeug routing>r¸ ) r^ r r Zto_urlr7 r r@ r Ú_IF_KWARGS_URL_ENCODE_ASTr± Ú_URL_ENCODE_AST_NAMESrj ZReturnÚTupler¿ rr rO r3 r9 ÚargÚkwargrà rl rk rm Ú _attributesrÌ rÍ rÎ rÏ r r¹ )rC rº Zdom_opsZurl_opsZoplrÅ r r Z dom_partsZ url_partsrl rÊ ZpargsZkargsZfunc_astrÓ Ú_Úmodulerq r· r )rÁ r^ r r³ Ñ sp
|
þÿ
|
ÿ
|
þ
|
zRule._compile_builderztuple[str, str] | None)Úvaluesrº r' c C s@ z$|r| j f |W S | jf |W S W n tk
|
r: Y dS X dS )zAssembles the relative url for that rule and the subdomain.
|
If building doesn't work for some reasons `None` is returned.
|
|
:internal:
|
N)r¶ rµ r )rC rØ rº r r r Úbuild9 s z
|
Rule.buildc C s2 t | j o.| jo.| j|jko.| |ko.| j|jkS )zNCheck if this rule has defaults for a given rule.
|
|
:internal:
|
)r rd r^ rW r )rC rO r r r Úprovides_defaults_forI s ÿ
|
þý
|
ûzRule.provides_defaults_for)rØ Úmethodr' c C s |dk r | j dk r || j kr dS | jp(d}| jD ]}||kr0||kr0 dS q0|r|| ¡ D ]"\}}||krX||| krX dS qXdS )z\Check if the dict of values has enough data for url generation.
|
|
:internal:
|
NFr T)rc r^ r r_ )rC rØ rÛ r^ rf r$ r r r Ú suitable_forV s
|
ÿþý
|
|
zRule.suitable_forztuple[int, int, int]c C s( | j r
|
dndt| j t| jp d fS )z?The build compare key for sorting.
|
|
:internal:
|
r
|
r r )rx r* r r^ r r r r Úbuild_compare_keyw s zRule.build_compare_keyÚobject)Úotherr' c C s t |t| o| j|jkS rI )r` r r )rC rß r r r Ú__eq__~ s z Rule.__eq__c C s | j S rI )rO r r r r Ú__str__ s z Rule.__str__c C s¨ | j d kr dt| j dS g }| jD ]*\}}|rF| d| d¡ q&| |¡ q&d |¡ d¡}| jd k rdd | j¡ dnd}dt| j d || d
|
| j dS ) Nú<z (unbound)>r£ r r¯ z (z, r¤ ú z -> ) r@ r r r r7 ÚjoinÚlstriprc rW )rC rÈ rÅ r rc r r r Ú__repr__ s
|
"z Rule.__repr__) NNNFNNNNFNF)F)T)T)N)r r r r rJ rL r rD r r r r r® r Ú staticmethodr¹ r³ rÙ rÚ rÜ rÝ rà Ú__hash__rá ræ r r r r rb 8 sJ ó(:
|
]" ÿi ÿ ÿ!rb )0Ú
|
__future__r rj r© ÚtypingÚtZ dataclassesr ru r Útypesr Ú urllib.parser Zdatastructuresr Úurlsr r r Ú TYPE_CHECKINGr r@ r Ú
|
NamedTupler r r ÚVERBOSEr¦ Z_simple_rule_rer4 r- r+ r0 r< r= rE rQ rU rX rZ rr r½ Z_IF_KWARGS_URL_ENCODE_CODErÐ rÑ rb r r r r Ú<module> sR í
|
ô '
|
