%h~SSKJr SSKrSSKrSSKrSSKJr SSKJ r SSK J r SSK J r SSKJr SS KJr S S KJr \R((a S S KJr S S KJr "SS\R05r\"SS55r\R6"S\R85r\R6"S5r\R6"S\R85rSSSS.r S0Sjr!S1Sjr"S2Sjr#"SS5r$"SS\$5r%"SS \$5r&"S!S"\$5r'"S#S$5r("S%S&\$5r)\RT"S'\RVS(9r,S3S)jr-S*r.S+r/\-"\/\R`5r1\-"S,\Rd5\-"S-\Rd54r3"S.S/\$5r4g)4) annotationsN) dataclass)Template)CodeType)quote)iter_multi_items) _urlencode)ValidationError) BaseConverter)Mapc>\rSrSr%S\S'S\S'S\S'S\S'S rg ) Weightingintnumber_static_weightszlist[tuple[int, int]]static_weightsnumber_argument_weightsz list[int]argument_weightsN)__name__ __module__ __qualname____firstlineno____annotations____static_attributes__rN/var/www/auris/envauris/lib/python3.13/site-packages/werkzeug/routing/rules.pyrrs))  rrcL\rSrSr%SrS\S'S\S'S\S'S\S'S \S 'S rg ) RulePartaA 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. strcontentboolfinalstaticsuffixedrweightrN)rrrr__doc__rrrrrr!r!s#L K LN rr!a (?: (?P/) # a slash | (?P[^[a-zA-Z_][a-zA-Z0-9_]*) # converter name (?:\((?P.*?)\))? # converter arguments : # variable delimiter )? (?P[a-zA-Z_][a-zA-Z0-9_]*) # variable name > ) ) z <([^>]+)>z \s* ((?P\w+)\s*=\s*)? (?P True|False| \d+.\d+| \d+.| \d+| [\w\d_.]+| [urUR]?(?P"[^"]*?"|'[^']*') )\s*, TF)NoneTrueFalsec\URX5$![a [U5s$f=f)z_Find the *target* in *value* after *pos*. Returns the *value* length if *target* isn't found. )index ValueErrorlen)valuetargetposs r_findr5Xs/ {{6'' 5zs ++cU[;a [U$[[4H nU"U5s $ USSUSS:XaUSS;aUSSn[ U5$![a MBf=f)Nr rz"')_PYTHON_CONSTANTSrfloatr0r#)r2converts r _pythonizer;cs} !! '': 5> !  RayE"#J58u#4a  u:    sA A#"A#cUS- n/n0nSn[RU5HnUR5U:wa[SXUR5S35eUR S5nUcUR S5n[ U5nUR S5(dUR U5 OUR S5nXRU'UR5nM [U5U4$)N,rz!Cannot parse converter argument '' stringvalr2name) _converter_args_refinditerstartr0groupr;appendendtuple)argstrargskwargspositionitemr2r@s rparse_converter_argsrMps cMF D FH"++F3 ::<8 #3FDJJL4Q3RRST  ;' =JJw'E5!zz&!! KK ::f%D 4L88:4" ; rc"\rSrSrSrSSjrSrg) RuleFactoryzAs 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`. c[5e)zYSubclasses of `RuleFactory` have to override this method and return an iterable of rules.)NotImplementedErrorselfmaps r get_rulesRuleFactory.get_ruless "##rrN)rUrreturnt.Iterable[Rule])rrrrr*rVrrrrrOrOs  $rrOc,\rSrSrSrSSjrSSjrSrg) 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('', [ 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. cXlX lgN) subdomainrules)rTr_r`s r__init__Subdomain.__init__s " rc## URH@nURU5H(nUR5nURUlUv M* MB g7fr^)r`rVemptyr_rTrU rulefactoryrules rrVSubdomain.get_rulessC::K#--c2zz|!% 3&sAA)r`r_N)r_r#r`t.Iterable[RuleFactory]rXr+rUrrXzt.Iterator[Rule]rrrrr*rarVrrrrr[r[s$rr[c,\rSrSrSrSSjrSSjrSrg) SubmountaYLike `Subdomain` but prefixes the URL rule with a given string:: url_map = Map([ Rule('/', endpoint='index'), Submount('/blog', [ Rule('/', endpoint='blog/index'), Rule('/entry/', endpoint='blog/show') ]) ]) Now the rule ``'blog/show'`` matches ``/blog/entry/``. c<URS5UlX lg)N/)rstrippathr`)rTrrr`s rraSubmount.__init__sKK$  rc## URHMnURU5H5nUR5nURUR-UlUv M7 MO g7fr^)r`rVrdrrrgres rrVSubmount.get_rulessL::K#--c2zz| II 1  3&AA!)rrr`N)rrr#r`rirXr+rjrkrrrrmrms rrmc,\rSrSrSrSSjrSSjrSrg) EndpointPrefixadPrefixes 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/', endpoint='show') ])]) ]) cXlX lgr^prefixr`)rTr|r`s rraEndpointPrefix.__init__s   rc## URHMnURU5H5nUR5nURUR-UlUv M7 MO g7fr^)r`rVrdr|endpointres rrVEndpointPrefix.get_rulessL::K#--c2zz| $ dmm ;  3&rvr{N)r|r#r`rirXr+rjrkrrrrxrxs rrxc,\rSrSrSrSSjrSSjrSrg) RuleTemplatea,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/', 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. c$[U5Ulgr^)listr`)rTr`s rraRuleTemplate.__init__s %[ rc@[UR[U0UD65$r^)RuleTemplateFactoryr`dict)rTrIrJs r__call__RuleTemplate.__call__s"4::tT/DV/DEEr)r`N)r`rYrXr+)rIt.AnyrJrrXr)rrrrr*rarrrrrrrs$!Frrc8\rSrSrSrSSjrSSjrSrg) rizgA factory that fills in template variables into rules. Used by `RuleTemplate` internally. :internal: cXlX lgr^)r`context)rTr`rs rraRuleTemplateFactory.__init__ s  rc ## URGHqnURU5GHWnS=pEUR(ab0nURR5HBupg[ U[ 5(a$[ U5RUR5nXtU'MD URb.[ UR5RUR5nURn[ U[ 5(a$[ U5RUR5n[[ UR5RUR5UUURURUUR5v GMZ GMt g7fr^)r`rVdefaultsitems isinstancer#r substituterr_rRulergmethods build_onlystrict_slashes) rTrUrfrg new_defaultsr_keyr2 new_endpoints rrVRuleTemplateFactory.get_ruless"::K#--c2+// ==#%L&*mm&9&9&; %eS11$,UO$>$>t||$LE,1S)'<>>- ( 8 C CDLL QI#}} lC00#+L#9#D#DT\\#RLTYY'224<<@ LLOO ''3&sFF)rr`N)r`rirzdict[str, t.Any]rXr+rjrkrrrrrs) ,7G  rr_ASTT)boundc[R"U5RSn[U[R5(a UR n[X!5(d.[ S[U5RSUR35e[R"U5H8n[U[R5(dM$SUR3Ul M: U$)zEast parse and prefix names with `.` to avoid collision with user varsrzAST node is of type z, not .) astparsebodyrExprr2 TypeErrortyperwalkNameid)src expected_typetreenodes r _prefix_namesr,sIIcN''*D$!!zz d * *"4:#6#6"7vm>T>T=U V   dCHH % %$''mDG Krz#self._converters[{elem!r}].to_url()zpif kwargs: params = self._encode_query_vars(kwargs) q = "?" if params else "" else: q = params = "" qparamsct\rSrSrSrSSSjjrSSjrSSjrSSjrSSjr SSS jjr S S jr S!S jr S"S jr SS jr\S#Sj5rS$S%SjjrS$S&SjjrS'SjrS(S)SjjrS*SjrS+SjrSrS,SjrS,SjrSrg)-riJaA 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 ```` 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/', 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='', endpoint='user/homepage'), Rule('/stats', subdomain='', 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/', endpoint='foo'), Rule('/some/old/url/', redirect_to='foo/'), Rule('/other/old/url/', 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. Nc URS5(d[SUS35eXlURS5(+UlURS5UlSUlXplXlX0l Xl X l XPl Xl XlUbz[U[ 5(a [#S5eUV s1sHoR%5iM nn SU;aSU;aUR'S5 U (aU1Sk- (a [S5eX@lX`lXlU(a[/[ [ U55UlO[/5Ul0Ul/Ul/Ulgs sn f) Nrpz URL rule 'z' must start with a slash.z&'methods' should be a list of strings.HEADGET>rrOPTIONSzBWebSocket rules can only use 'GET', 'HEAD', and 'OPTIONS' methods.) startswithr0rgendswithis_leaf is_branchrUr merge_slashesr_hostrralias websocketrr#rupperaddrr redirect_toset arguments _converters_trace_parts)rTstringrr_rrrrrrrrrxs rra Rule.__init__s<  %%z&1KLM M !??3// -,*"  $ "  '3'' HII*12'Qwwy'G2W$')9 F#W'AA X ' &  S(!34DN UDN57.0 &( +3s;E.cV[U5"UR40UR5D6$)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. )rrgget_empty_kwargsrTs rrd Rule.emptys%Dz$))?t'<'<'>??rc SnUR(a[UR5n[UURURURUR UR URURURS9 $)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) rr_rrrrrrr) rrr_rrrrrrr)rTrs rrRule.get_empty_kwargssj ==DMM*HnnLL]]..((**  rc## Uv g7fr^rrSs rrVRule.get_rules+s  sc8URURSS9 g)zYRebinds and refreshes the URL. Call this if you modified the rule in place. :internal: T)rebindN)bindrUrs rrefresh Rule.refresh.s $((4 (rcFURb$U(d[SU<SUR<35eXlURcURUlURcURUlURcUR UlUR 5 g)zBind 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 )rU RuntimeErrorrrr_default_subdomaincompile)rTrUrs rr Rule.bind6s 88 4(2H UV V    &"%"4"4D     %!$!2!2D  >> ! 22DN rcX RR;a[SU<S35eURRU"UR/UQ70UD6$)zGLooks up the converter for the given parameter. .. versionadded:: 0.9 zthe converter z does not exist)rU converters LookupError)rT variable_nameconverter_namerIrJs r get_converterRule.get_converterGsQ !4!4 4~.@PQ Qxx"">2488MdMfMMrc[U5nURR(a[X RRS9n[ U5$)N)r)r rUsort_parameterssortedsort_keyr )rT query_varsrs r_encode_query_varsRule._encode_query_varsVs8-=j-I 88 # #5hh&7&78E%  rc## SnSn/n/nSnSnSnU[U5:Ga>[RX5n U c[SU<35eU R 5n U SbpUR [U5[U S5*45 UR R SU S45 X#(aU SO[R"U S5- nU SbU(a[R"U5nSn[U S=(d S5upURU SU S =(d S X5n XRU S'URRU S5 U R(dSnUS US U RS 3- nUS- nUR U R 5 UR R SU S45 U SbqUR R S5 U(aUS- nOIU(dUS- n[#[U5*U[U5*U5n[%UUUSUS9v SnSn/n/nSnSnU R'5nU[U5:aGM>SnU(aUSS:Xa SnUSSS-nU(dUS- n[#[U5*U[U5*U5n[%UUUUUS9v U(a[%SSSSUS9v gg7f)NTFrzmalformed url rule: r'variabler converterdefaultz(?P<__werkzeug_>)r slash)Frprpz\Zr$r&r'r(r)r7z (?':Sh=P#:;V4>4>9RRJ+ ii0G#7[8I8OR#P ,,$d;&7&D9f6=  j!12""4 #34-- E_-=,>a aPP A%  ''7 ""D$z*:#;<G}( ""<0sNG!5(&^,,&-..( F # '#%!&% !G!F')$%'N!E'($))+CqCIot WR[C'Hcrl\1G u G   ! " "        %uV  s IKA1Kc *URcS5eURR(aUR=(d SnOUR=(d Sn/Ul/Ul0UlUS:Xa [SSSS[S/S/5S9/UlO*URRURU55 UR RS5 URnUR(a"[R"S S UR5nURRURU55 U UR!S5R#US5UlU UR!S5R#US5Ulg) z.Compiles the regular expression and stores it.Nzrule not boundrFTrr)F|z/{2,}?rp)rU host_matchingrr_rrrr!rextendrrErgrrsub_compile_builder__get___build_build_unknown)rT domain_rulergs rr Rule.compilesDxx#5%55# 88 ! !))/rK...BK   " "$QAr2 DK KK  t// < = <(yy   66(C3D 4++D12 ++E2::4F  "33D9AA$Mrc*0n0n[XU5 X1$r^)exec)coder@globslocss r_get_func_codeRule._get_func_codes"$!# T$zrc <^UR=(d 0n/n/nUnURHupgUS:XaXSLaUnMU(a:Xr;a5URURX'5nUR SU45 MTU(dUR S[ USS945 MxUR SU45 M SSjmSU4SjjnU"U5n U"U5n U(d/n O[ /n U R[5 SSjn U R [R"[R"U "U 5U "U 5/[R"5555 X4-VV s/sHupmU(dMX;dMU PM nnn UVs/sHn[U5PM nn[S [R5nS UR <S 3UlUR$R$R [R&"S S55 UU-H=nUR$R$R [R&"US55 M? [R&"S S5UR$lUH<nUR$RR [R*"S55 M> U Ul[R."S5nU/Ul[R0"U5HunSUR2;aSUlSUR2;aUR4UlSUR2;aSUlSUR2;dMdUR8UlMw [=USS5nUR?UUR"5$s sn nfs snf)NrFz!$&'()*+,/:;=@)safeTc[[RUS9[R5n[R "U[R "55/UlU$)N)elem)r_CALL_CONVERTER_CODE_FMTformatrCallrLoadrI)rrets r_convert'Rule._compile_builder.._convertsA 8 ? ?T ? JCHHUCsxxz23CHJrc>UVVs/sH*upU(aT"U5O[R"U5PM, nnnU=(d [R"S5/nUS/nUSSHn[U[R5(aW[US[R5(a5[R"USRUR-5US'MyUR U5 M U$s snnf)Nrrr r7)rConstantrr2rE)ops is_dynamicrpartsrprs rr%Rule._compile_builder.._partss),%(+$J#-#,,t2DD(+ %/cll2./E8*C12Ya..:c"gs||3T3T!ll3r7==177+BCCGJJqM  J%s1C6cV[U5S:XaUS$[R"U5$)Nr r)r1r JoinedStr)r"s r_join$Rule._compile_builder.._joins%5zQQx==' 'rz def _(): passz r )rr#rXzast.Call)r zlist[tuple[bool, str]]rXlist[ast.expr])r"r-rXzast.expr) rrrto_urlrEr_IF_KWARGS_URL_ENCODE_ASTr_URL_ENCODE_AST_NAMESrReturnTuplerr#r FunctionDefrgr@rIargkwargrrrr _attributesr)r*r+r,rr)rTappend_unknownrdom_opsurl_opsoplr!rr dom_parts url_partsrr'rpargskkargsfunc_astr4_modulerrrs @rrRule._compile_builders==&B*,*, $ Js{s~d.''-44X^D E4=) E54D#EFG D$<(!,   7O 7O D-.D   2 3 ( JJsyy% "2E)4D!EsxxzR S %,$5 $5  "2 $5  "**AQ* #//B#DII=2  !!#'''4"895=C MM   % %cggc4&8 9!!ggi6 A MM " " ) )#,,r*: ; 2j HHV$D4+++ t///"&++t///"#4#3#33&*oo#%v3V<""477I +s" N3N:NNczU(aUR"S0UD6$UR"S0UD6$![a gf=f)zAssembles the relative url for that rule and the subdomain. If building doesn't work for some reasons `None` is returned. :internal: Nr)r rr )rTvaluesr7s rbuild Rule.buildHsB **4V44{{,V,,  s-- ::c[UR(+=(aW UR=(aD URUR:H=(a$ X:g=(a URUR:H5$)z>Check if this rule has defaults for a given rule. :internal: )r%rrrr)rTrgs rprovides_defaults_forRule.provides_defaults_forXs_   1  1 . 1  1$..0   rcUbURbX R;agUR=(d SnURHnXC;dM XA;dM g U(a*UR5HupEXA;dM XQU:wdM g g)zLCheck if the dict of values has enough data for url generation. :internal: FrT)rrrr)rTrEmethodrrr2s r suitable_forRule.suitable_fores{   (ll*==&B>>C"s'8" &nn. =USk%9 /rcUR(aSOS[UR5*[UR=(d S5*4$)z/The build compare key for sorting. :internal: r rr)rr1rrrs rbuild_compare_keyRule.build_compare_keys7 ZZQT^^)<(WXXrcl[U[U55=(a URUR:H$r^)rrr)rTothers r__eq__ Rule.__eq__s%%d,L 1LLrcUR$r^)rgrs r__str__ Rule.__str__s yyrcURcS[U5RS3$/nURH4up#U(aUR SUS35 M#UR U5 M6 SR U5R S5nURbSSR UR5S3OSnS[U5RS U<US URS3$) Nrrrz (z, r z -> ) rUrrrrEjoinlstriprr)rTr"r!r parts_strrs r__repr__ Rule.__repr__s 88 tDz**+;7 7 $ J qa[) T" !, GGEN))#. 59\\5MBtyy./q1SU4:&&'q gYd4==/QRSSr)rr rrrrrrrrrrrrUrrrrgrr_r) NNNFNNNNFNF)rr#rzt.Mapping[str, t.Any] | Noner_ str | Nonerzt.Iterable[str] | Nonerr%rz t.Any | Noner bool | Nonerrbrz!str | t.Callable[..., str] | Nonerr%rrarr%rXr+)rXr)rXt.Mapping[str, t.Any]rj)rXr+)F)rUrrr%rXr+) rr#rr#rIztuple[t.Any, ...]rJrcrXr )rrcrXr#)rgr#rXzt.Iterable[RulePart])rrr@r#rX t.Callable[..., tuple[str, str]])T)r7r%rXrd)rErcr7r%rXztuple[str, str] | None)rgrrXr%r^)rErcrLrarXr%)rXztuple[int, int, int])rSobjectrXr%)rXr#)rrrrr*rardrrVrrrrrr staticmethodrrrFrIrMrPrT__hash__rWr_rrrrrrJs~F26 $*. !%&*%)9=9)9)/9) 9) ( 9)  9)9)$9)#9)79)9)9)9) 9)v@ 6)" N N N N & N  N![z ND&*b8"b8 )b8JEI+=A   CG+5? BYMH Trr)r2r#r3r#r4rrXr)r2r#rXzNone | bool | int | float | str)rHr#rXz*tuple[tuple[t.Any, ...], dict[str, t.Any]])rr#rz type[_ASTT]rXr)5 __future__rrrtypingt dataclassesrrrtypesr urllib.parserdatastructuresr urlsr rr TYPE_CHECKINGr rUr NamedTuplerr!rVERBOSEr_simple_rule_rerAr8r5r;rMrOr[rmrxrrTypeVarASTrrr_IF_KWARGS_URL_ENCODE_CODEIfr/rr0rrrrrxs" !-'??)     " ::$JJ' ,**\*ZZ JJ""4%@ 4 $ $ >{4[2FF4$+$N ') A**DcffM#sxx (CHH% V T;V Tr