hs H%SrSSKJr SSKrSSKrSSKrSSKrSSKrSSK J r SSK J r SSK J r SSK J r SSK Jr S S KJr S S KJr S S KJr S S KJr S SKJr \R,(aS SKJr \R2"S5rSr\"\R;S55rSr\VVs0sH.n\H$nUU3R;S5\ "UU3S5_M& M0 snnr!\""S5Vs/sHnSUS3R;S5PM snr#"SS\RH5r%"SS\%5r&"SS\&5r'"SS\&5r(\"5\!0r)S \*S!'SHSIS"jjr+SJS#jr,SHSKS$jjr-SLSMS%jjr.SNSOS&jjr/\/"5r0\/"S'S(S)9r1SPS*jr2SNSQS+jjr3SRSSS,jjr4STS-jr5SUSVS.jjr6SWSXS/jjr7SYSZS0jjr8S[S1jr9\Rt"S2\95 S\S3jr;\<"/\""S45QS5PS6P75R{5r>\;"S7\>5r?\;"S8\>S9-5r@\;"S:\>S;-5rA\;"S<\>S=-5rBS]S^S>jjrCS_S`S?jjrDSaS@jrESbScSAjjrFSdSeSBjjrGSfSCjrHSgShSDjjrISiSjSEjjrJSkSlSFjjrKSYSmSGjjrLgs snnfs snf)nzFunctions for working with URLs. Contains implementations of functions from :mod:`urllib.parse` that handle bytes and strings. ) annotationsN)quote)unquote) urlencode)urlsplit) urlunsplit)_check_str_tuple) _decode_idna)_make_encode_wrapper)_to_striter_multi_items)datastructuresz^[a-zA-Z0-9+-.]+$zKabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~$!'()*+,;ascii0123456789ABCDEFabcdef%02XcH\rSrSr%S\S'S\S'S\S'S\S'S\S'Srg ) _URLTuple2strschemenetlocpathqueryfragmentN)__name__ __module__ __qualname____firstlineno____annotations____static_attributes__r bC:\Users\ROHAN GUPTA\OneDrive\Desktop\mathbuddy-assessment\venv\Lib\site-packages\werkzeug/urls.pyrr2s K K I JMr'rc^\rSrSr%SrSrS\S'S\S'S\S'S\S'SU4S jjrS S jrS!S jr \ S"S j5r \ S"S j5r \ S#Sj5r \ S"Sj5r\ S"Sj5r\ S"Sj5r\ S"Sj5r\ S"Sj5rS$SjrSSjrS SjrS SjrS SjrS%SjrS%SjrS&S'SjjrS(SjrS)SjrS)SjrSrU=r$)*BaseURL:zSuperclass of :py:class:`URL` and :py:class:`BytesURL`. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use the ``urllib.parse`` library instead. r r_at_colon _lbracket _rbracketc|>[R"SURS3[SS9 [TU]"U/UQ70UD6$)Nz'werkzeug.urls.z\' is deprecated and will be removed in Werkzeug 3.0. Use the 'urllib.parse' library instead. stacklevel)warningswarnr!DeprecationWarningsuper__new__)clsargskwargs __class__s r(r8BaseURL.__new__GsG cll^,E E   ws4T4V44r'c"UR5$N)to_urlselfs r(__str__BaseURL.__str__Ps{{}r'c &UR"S0UD6$)z~Return an URL with the same values, except for those parameters given new values by whichever keyword arguments are specified.r )_replace)rBr;s r(replaceBaseURL.replaceSs}}&v&&r'c(UR5S$)zThe host part of the URL if available, otherwise `None`. The host is either the hostname or the IP address mentioned in the URL. It will not contain the port. r) _split_hostrAs r(host BaseURL.hostXs !!$$r'cURnUb8[U[5(a#URS5R S5nU$U$![ a U$f=f)aWorks exactly like :attr:`host` but will return a result that is restricted to ASCII. If it finds a netloc that is not ASCII it will attempt to idna decode it. This is useful for socket operations when the URL might include internationalized characters. idnar)rK isinstancerencodedecode UnicodeErrorrBrvs r( ascii_hostBaseURL.ascii_host`s`YY >jS11 YYv&--g6 r     s A AAc[[UR5S55nSUs=::aS::aU$ gg![[4a gf=f)zmThe port in the URL as an integer if it was present, `None` otherwise. This does not fill in default ports. r riN)intr rJ ValueError TypeErrorrSs r(port BaseURL.portosf  WT--/234BB%    I&   s4;;A Ac(UR5S$)zCThe authentication part in the URL if available, `None` otherwise. r) _split_netlocrAs r(auth BaseURL.auth|s !!#A&&r'cFUR5SnUb [U5$g)zsThe username if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a string. rN _split_auth_url_unquote_legacyrSs r(usernameBaseURL.username*     " >&r* *r'c(UR5S$)zqThe username if it was part of the URL, `None` otherwise. Unlike :attr:`username` this one is not being decoded. rrcrAs r( raw_usernameBaseURL.raw_username !!$$r'cFUR5SnUb [U5$g)zsThe password if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a string. r NrbrSs r(passwordBaseURL.passwordrgr'c(UR5S$)zqThe password if it was part of the URL, `None` otherwise. Unlike :attr:`password` this one is not being decoded. r rirAs r( raw_passwordBaseURL.raw_passwordrlr'c4[UR/UQ70UD6$)zDecodes the query part of the URL. Ths is a shortcut for calling :func:`url_decode` on the query argument. The arguments and keyword arguments are forwarded to :func:`url_decode` unchanged. ) url_decoderrBr:r;s r( decode_queryBaseURL.decode_querys $**6t6v66r'c2[[U/UQ70UD65$)zJoins this URL with another one. This is just a convenience function for calling into :meth:`url_join` and then parsing the return value again. ) url_parseurl_joinrus r(join BaseURL.joins $88899r'c[U5$)zReturns a URL string or bytes depending on the type of the information stored. This is just a convenience function for calling :meth:`url_unparse` for this URL. ) url_unparserAs r(r@BaseURL.to_urls 4  r'c FUR=(d SnSU;aSUS3nURnUbUSU3nSR[S[ UR =(d SSSS5[ UR =(d SSSS5/55nU(aUS U3nU$) z6Encodes the netloc part to an ASCII safe URL as bytes.:[]Nutf-8strictz/:%@)rUr[r{filter url_quoterjrq)rBrTr[r_s r( encode_netlocBaseURL.encode_netlocs __ " "9RDByy  4qBxx d//52w%Pd//52w%P   62$B r'c UR=(d Sn[U[5(aUR5n[ U5nSU;aSUS3nUR nUbUSU3nSR [S[UR=(d SS5[UR=(d SS5/55nU(aUSU3nU$)z&Decodes the netloc part into a string.rrrrNz/:%@r) rKrObytesrQr r[r{rrdrjrq)rBrKrTr[r_s r( decode_netlocBaseURL.decode_netlocsyyB dE " ";;=D $  "9RDByy  4qBxx '(9(9(?RH'(9(9(?RH   62$B r'c*[[U55$)aReturns a :class:`BytesURL` tuple that holds a URI. This will encode all the information in the URL properly to ASCII using the rules a web browser would follow. It's usually more interesting to directly call :meth:`iri_to_uri` which will return a string. )ry iri_to_urirAs r( to_uri_tupleBaseURL.to_uri_tuplesD)**r'c*[[U55$)a#Returns a :class:`URL` tuple that holds a IRI. This will try to decode as much information as possible in the URL without losing information similar to how a web browser does it for the URL bar. It's usually more interesting to directly call :meth:`uri_to_iri` which will return a string. )ry uri_to_irirAs r( to_iri_tupleBaseURL.to_iri_tuplesD)**r'c^URS:wag[UR5nUR=(d SnUc[R S:XaSnOSnUS:XaUSSS:Xa.USS R 5(aUS S S ;a USS S US S3nUSS S ;nSSKnURU5nU(a?Uc<URS5RSS5n[U5S :XaUup2O3USnSnO+US:XaSSK nURU5nO[SU<35eUS;aSnX24$)aReturns a tuple with the location of the file in the form ``(server, location)``. If the netloc is empty in the URL or points to localhost, it's represented as ``None``. The `pathformat` by default is autodetection but needs to be set when working with URLs of a specific system. The supported values are ``'windows'`` when working with Windows or DOS paths and ``'posix'`` when working with posix paths. If the URL does not point to a local file, the server and location are both represented as ``None``. :param pathformat: The expected format of the path component. Currently ``'windows'`` and ``'posix'`` are supported. Defaults to ``None`` which is autodetect. fileNNNntwindowsposixr /r1z|:r)z\\\z///r\rzInvalid path format )z 127.0.0.1z::1 localhost)r url_unquoterrosnameisalphantpathnormpathlstripsplitlen posixpathrZ)rB pathformatrrK windows_sharerpartsrs r(get_file_locationBaseURL.get_file_locationsI( ;;& 499%{{"d  ww$& $  "BQx34!9#4#4#6#64!9;Lq)Ad12hZ0 !H(;;M ??4(D  D)//a8u:?!&JD$ 8DD 7 " %%d+D2:.AB B 4 4Dzr'cURUR;a+URRUR5upnX4$SUR4$r?)r,r partition)rBr__rs r(r^BaseURL._split_netloc=sE 88t{{ ""kk33DHH=ODV< T[[  r'cUR5SnU(dgURU;aUS4$URUR5up#nX$4$)Nrr)r^r-r)rBr_rerrns r(rcBaseURL._split_authCsQ!!#A& ;;d ":  $t{{ ;X!!r'cUR5SnU(dgURUR5(d5URU;a!UR UR5up#nX$4$US4$UR UR 5nUS:aUS4$USUnXS-SnURUR5(aX&SS4$US4$)Nr rr)r^ startswithr.r-rfindr/)rBrTrKrr[idxrests r(rJBaseURL._split_hostMs    !! $}}T^^,,{{b " T[[ 9 z!t8Oggdnn% 7t8O!Cy')} ??4;; ' 'ab> !Tzr')r:t.Anyr;rreturnr*rr)r;rrr*)r str | None)r int | None)r:rr;rrds.MultiDict[str, str])rr*r?)rrrtuple[str | None, str | None])rztuple[str | None, str])rr) r!r"r#r$__doc__ __slots__r%r8rCrGpropertyrKrUr[r_rerjrnrqrvr{r@rrrrrr^rcrJr& __classcell__)r<s@r(r*r*:s$ I H KNN5' %%    '' %% %% 7:!*6+ +(,<$< &<|! "r'r*c:\rSrSrSrSrSrSrSrSr S S Sjjr Sr g ) URLiczRepresents a parsed URL. This behaves like a regular tuple but also has some extra attributes that give further insight into the URL. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use the ``urllib.parse`` library instead. r rrrrc [URRS5UR5URRX5UR RX5UR RX55$)zpEncodes the URL to a tuple made out of bytes. The charset is only being used for the path, query and fragment. r)BytesURLrrPrrrrrBcharseterrorss r(rP URL.encoderse KK  w '    II  W - JJ  g . MM  1   r'NrrG)rrrrrr) r!r"r#r$rrr,r-r.r/rPr&r r'r(rrcs,I C FII   r'rcN\rSrSrSrSrSrSrSrSr S Sjr S S jr SSS jjr Sr g )rizRepresents a parsed URL in bytes. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use the ``urllib.parse`` library instead. r @:[]cBUR5RSS5$)NrrG)r@rQrAs r(rCBytesURL.__str__s{{}##GY77r'cUR$)z&Returns the netloc unchanged as bytes.)rrAs r(rBytesURL.encode_netlocs {{r'c [URRS5UR5URRX5UR RX5UR RX55$)zrDecodes the URL to a tuple made out of strings. The charset is only being used for the path, query and fragment. r)rrrQrrrrrs r(rQBytesURL.decodese KK  w '    II  W - JJ  g . MM  1   r'Nr)rrr)rrrrrr)r!r"r#r$rrr,r-r.r/rCrrQr&r r'r(rrs6 I C FII8   r'rz&dict[frozenset[int], dict[bytes, int]] _unquote_mapsc[U[5(aURS5n[U[5(aURS5n[[ U55n[ UR S55n[ [US55n[UnUHXnUSSnX;a)URXH5 URUSS5 M6URS5 URU5 MZ [U5$![aC [R5VVs0sHupVXa;dM XV_M Os snnfsnn=n[U'Nf=f)Nr%r'r1%)rOrrP frozenset bytearrayiterrnextrKeyError _hextobyteitemsappendextendr) stringunsafegroupsresult hex_to_bytehbgroupcodes r(_unquote_to_bytesrs&&#w'&#w' y( )F &,,t$ %F tFC( )F #F+ Ray   MM++ , MM%) $ MM"  MM%  =  '--// /TQ1?DAD//  mF+ s$ D!E$ D:3D:9EEc#f# SSKJn U"U5nU(a [XSS9nUHupgUcM [U[5(d[ U5R U5nOUn[U[5(d[ U5R U5n OUn [U5S[U 53v M g7f)Nr r)key=)rrsortedrOrrrP_fast_url_quote_plus) objrsortrriterablekey_str value_str key_bytes value_bytess r(_url_encode_implrs 1,# UHoT"S5;v M g7f) 0123456789Nr ).0css r( url_parse.. sBTAlO3Ts///?#rrzInvalid IPv6 URL#?)r4r5r6r rOrr _scheme_rematchr anylowerrminrYrrr)urlrallow_fragments is_text_basedrrrirdelimrwdelim result_typers @r(ryrys$ MM 0  S!AsC(M ~2 !"%F%U 3A1u!!'#bq')"DEEq57|sBTBBBbq'--/4C 2Aw!D'C5AXXa^F{E*!ElCK cFf 3v!5 cFf 3v!5/0 01S6S= !C&!, v}YYqvq) &#HK vs8 <SRUVs/sHnTUPM sn5$s snfNr)r{)rrtables r(r#_make_fast_url_quote..quote=s(ww&1&Qa&1221s'rrrr)rOrrPrr _always_saferangechr)rrsaferrrrs @r(_make_fast_url_quoter%$s ${{7+&#w/ io & 59VCT9U UD;@: F:aDySV!Ck 1: FE3 L Gs B8 +)r$rc8[U5RSS5$)Nr&r')_fast_quote_plusrG)rs r(rrGs F # + +C 55r'c[R"S[SS9 [U[[ [ 45(d [ U5n[U[5(aURX5n[U[5(aURX5n[U[5(aURX5n[[ U55[-[[ U55- n[ 5n[ U5H3nXc;aURU5 MUR[U5 M5 [ U5RU5$)aURL encode a single string with a given encoding. :param s: the string to quote. :param charset: the charset to be used. :param safe: an optional sequence of safe characters. :param unsafe: an optional sequence of unsafe characters. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use ``urllib.parse.quote`` instead. .. versionadded:: 0.9.2 The `unsafe` parameter was added. zn'werkzeug.urls.url_quote' is deprecated and will be removed in Werkzeug 3.0. Use 'urllib.parse.quote' instead.r1r2)r4r5r6rOrrrrPrr!rr _bytetohexrQ)rrrr$rrTchars r(rrKs( MM -  fsE95 6 6V&#w/${{7+&#w/ io & 59VCT9U UD B&! < IIdO IIj& ' " 9  G $$r'cv[R"S[SS9 [XX#S-S5R SS5$)a3URL encode a single string with the given encoding and convert whitespace to "+". :param s: The string to quote. :param charset: The charset to be used. :param safe: An optional sequence of safe characters. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use ``urllib.parse.quote_plus`` instead. zx'werkzeug.urls.url_quote_plus' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.quote_plus' instead.r1r2r&r')r4r5r6rrG)rrrr$s r(url_quote_plusr.xs= MM 7  VfSj# > F FsC PPr'c[R"S[SS9 [U5 Uupp4n[ U5nU"S5nU(d#U(a[UR U"S55(a?U(aUSSU"S5:wa U"S5U-nU"S5U=(d U"S5-U-nO U(aXs- nU(a X"S 5-U-nU(a Xv"S 5-U-nU(a Xv"S 5-U-nU$) aQThe reverse operation to :meth:`url_parse`. This accepts arbitrary as well as :class:`URL` tuples and returns a URL as a string. :param components: the parsed URL as tuple which should be converted into a URL string. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use ``urllib.parse.urlunsplit`` instead. zu'werkzeug.urls.url_unparse' is deprecated and will be removed in Werkzeug 3.0. Use 'urllib.parse.urlunsplit' instead.r1r2rrNr r rrr )r4r5r6r r r) componentsrrrrrrrs r(r~r~s MM 2  Z ,6)FDV$A B%C &T__QsV44 D!H#&S6D=Dg1R5)D0   qvo# AcFlU"AcFlX% Jr'cx[R"S[SS9 [X5nUcU$UR X5$)aURL decode a single string with a given encoding. If the charset is set to `None` no decoding is performed and raw bytes are returned. :param s: the string to unquote. :param charset: the charset of the query string. If set to `None` no decoding will take place. :param errors: the error handling for the charset decoding. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use ``urllib.parse.unquote`` instead. zr'werkzeug.urls.url_unquote' is deprecated and will be removed in Werkzeug 3.0. Use 'urllib.parse.unquote' instead.r1r2)r4r5r6rrQ)rrrrrTs r(rrs@$ MM /  1 %B 99W %%r'c[R"S[SS9 [U[5(aUR SS5nOUR SS5n[ XU5$)aURL decode a single string with the given `charset` and decode "+" to whitespace. Per default encoding errors are ignored. If you want a different behavior you can set `errors` to ``'replace'`` or ``'strict'``. :param s: The string to unquote. :param charset: the charset of the query string. If set to `None` no decoding will take place. :param errors: The error handling for the `charset` decoding. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use ``urllib.parse.unquote_plus`` instead. z|'werkzeug.urls.url_unquote_plus' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.unquote_plus' instead.r1r2r'r&+ )r4r5r6rOrrGr)rrrs r(url_unquote_plusr5sW" MM 9 !S IIc3  IIdD ! q6 **r'c[R"S[SS9 [XS5R SS5nUR S5(a)USS R 5(aUS S S ;aS USS 3n[U5n[URUSS9n[URUSS9n[URUSS9n[URUR5X4U45$)aSometimes you get an URL by a user that just isn't a real URL because it contains unsafe characters like ' ' and so on. This function can fix some of the problems in a similar way browsers handle data entered by the user: >>> url_fix('http://de.wikipedia.org/wiki/Elf (Begriffskl\xe4rung)') 'http://de.wikipedia.org/wiki/Elf%20(Begriffskl%C3%A4rung)' :param s: the string with the URL to fix. :param charset: The target charset for the URL if the url was given as a string. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. zJ'werkzeug.urls.url_fix' is deprecated and will be removed in Werkzeug 3.0.r1r2rGrrzfile:// )z:/z|/zfile:///Nz /%+$!*'(),r$z :&%=+$!*'(),)r4r5r6r rGrrryrrr.rrr~rr)rrrrqsanchors r(url_fixr=s  MMT I&..tS9A ||I1Qq6>>#3#3!B<8Oqug  A,C SXXw\ :D  7 @B CLL' GF  C$5$5$76J KKr'cr[URURURSS9nXR4$)zJUsed in :func:`uri_to_iri` after unquoting to re-quote any invalid bytes. rr:)robjectstartend)eouts r(_codec_error_url_quoterDs/ 155) 3C :r'werkzeug.url_quotec^SRS[U555n[R"SUS3[R5mSU4SjjnSU3UlU$)zCreate a function that unquotes all percent encoded characters except those given. This allows working with unquoted characters if possible while not changing the meaning of a given part of a URL. |c3<# UHn[U5Sv M g7f)rN)ord)rrs r(r %_make_unquote_part..-s> 1#a& sz((?:%(?:z))+)c>[TRU55n/nUH9nUR[XQU55 UR[ US55 M; SR U5$r)rrrrrr{)rencodingrrrCpartpatterns r(_unquote_partial,_make_unquote_part.._unquote_partial0sZW]]5)*D JJwtv6 7 JJtE2 'wws|r' _unquote_)rrrLrrrrr)r{rrecompileIr!)rcharschoicesrOrNs @r(_make_unquote_partrW(sW hh>u >>Gjj8G9D12448G#,D6 2 r'!rrrz&=+#rr userz:@/?#c[U[5(a%[R"S[SS9 [ U5n[U[ 5(a*[R"S[SS9 UR5nUb[R"S[SS9 OSnUb[R"S[SS9 OSn[U5n[URX5n[URX5n[URX5nUR(a[!UR5nOS nS U;aS US 3nUR"(aUS UR"3nUR$(aI['UR$X5nUR((aUS ['UR(X53nUS U3n[ UR*XtXV45$)aConvert a URI to an IRI. All valid UTF-8 characters are unquoted, leaving all reserved and invalid characters quoted. If the URL has a domain, it is decoded from Punycode. >>> uri_to_iri("http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF") 'http://\u2603.net/p\xe5th?q=\xe8ry%DF' :param uri: The URI to convert. :param charset: The encoding to encode unquoted bytes with. :param errors: Error handler to use during ``bytes.encode``. By default, invalid bytes are left quoted. .. versionchanged:: 2.3 Passing a tuple or bytes, and the ``charset`` and ``errors`` parameters, are deprecated and will be removed in Werkzeug 3.0. .. versionchanged:: 2.3 Which characters remain quoted is specific to each part of the URL. .. versionchanged:: 0.15 All reserved and invalid characters remain quoted. Previously, only some reserved characters were preserved, and invalid bytes were replaced instead of left quoted. .. versionadded:: 0.6 HPassing a tuple is deprecated and will not be supported in Werkzeug 3.0.r1r2FPassing bytes is deprecated and will not be supported in Werkzeug 3.0.JThe 'charset' parameter is deprecated and will be removed in Werkzeug 3.0.rIThe 'errors' parameter is deprecated and will be removed in Werkzeug 3.0.rErrrrr)rOtupler4r5r6rrrQr _unquote_pathr_unquote_queryr_unquote_fragmentrhostnamer r[re _unquote_userrnr) urirrrrrrrr_s r(rrHs>#u V  o#u T  jjl      W  & SME W 5D 5;; 8E AH ~~enn- f}VHA zz81UZZL) ~~U^^W= >>V1]5>>7KLMD66(# u||V5C DDr'cUb"S[SS9 OSn[U[5(a%[R"S[SS9 [ U5n[U[ 5(a+[R"S[SS9 URU5nUb"S[SS9 OSnUb[R"S [SS9 U(a2URS 5n[UR55S :XaU$[U5n[URS XS 9n[URSXS 9n[UR SXS 9nUR"(a+UR"RS5RS 5n OSn SU ;aSU S3n UR$(aU SUR$3n UR&(aG[UR&SS9n UR((a[UR(SS9n U SU 3n U SU 3n [ UR*XXx45$![a GN3f=f)aConvert an IRI to a URI. All non-ASCII and unsafe characters are quoted. If the URL has a domain, it is encoded to Punycode. >>> iri_to_uri('http://\u2603.net/p\xe5th?q=\xe8ry%DF') 'http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF' :param iri: The IRI to convert. :param charset: The encoding of the IRI. :param errors: Error handler to use during ``bytes.encode``. .. versionchanged:: 2.3 Passing a tuple or bytes, and the ``charset`` and ``errors`` parameters, are deprecated and will be removed in Werkzeug 3.0. .. versionchanged:: 2.3 Which characters remain unquoted is specific to each part of the URL. .. versionchanged:: 2.3 The ``safe_conversion`` parameter is deprecated and will be removed in Werkzeug 2.4. .. versionchanged:: 0.15 All reserved characters remain unquoted. Previously, only some reserved characters were left unquoted. .. versionchanged:: 0.9.6 The ``safe_conversion`` parameter was added. .. versionadded:: 0.6 r^r1r2rr\r]r_rzRThe 'safe_conversion' parameter is deprecated and will be removed in Werkzeug 3.0.rr z%!$&'()*+,/:;=@)r$rLrz%!$&'()*+,/:;=?@z%!#$&'()*+,/:;=?@rNrrrrz %!$&'()*+,;=r:r)r4r5r6rOr`rrrQrPrrrRrrrrrrdr[rernr) irirrsafe_conversion ascii_irirrrrrr_ pass_quoteds r(rrsH    #u V  o#u T  jj!  W  "       7+I9??$%* + SME "3g UD %++$6 XE 07H ~~&&v.55g> f}VHA zz81UZZL) ~~U^^.9 >>^DKV1[M*D66(# u||V5C DDA   s /H77 IIcURS5 [URSS55S:XaU$[ U5$![a Nf=f)aThe URL scheme ``itms-services://`` must contain the ``//`` even though it does not have a host component. There may be other invalid schemes as well. Currently, responses will always call ``iri_to_uri`` on the redirect ``Location`` header, which removes the ``//``. For now, if the IRI only contains ASCII and does not contain spaces, pass it on as-is. In Werkzeug 3.0, this should become a ``response.process_location`` flag. :meta private: rNr )rPrrrRr)rhs r(_invalid_iri_to_urirm sW 7 syyq! "a 'J ( c?    sA A  A c[R"S[SS9 UcSSKJn Un[ U[ 5(a0[ U[ 5(dURU=(d S5nOD[ U[5(a/[ U[5(dURU=(d S5nU"[URU5XU55$)ajParse a query string and return it as a :class:`MultiDict`. :param s: The query string to parse. :param charset: Decode bytes to string with this charset. If not given, bytes are returned as-is. :param include_empty: Include keys with empty values in the dict. :param errors: Error handling behavior when decoding bytes. :param separator: Separator character between pairs. :param cls: Container to hold result instead of :class:`MultiDict`. .. deprecated:: 2.3 Will be removed in Werkzeug 3.0. Use ``urllib.parse.parse_qs`` instead. .. versionchanged:: 2.1 The ``decode_keys`` parameter was removed. .. versionchanged:: 0.5 In previous versions ";" and "&" could be used for url decoding. Now only "&" is supported. If you want to use ";", a different ``separator`` can be provided. .. versionchanged:: 0.5 The ``cls`` parameter was added. zr'werkzeug.urls.url_decode' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.parse_qs' instead.r1r2r  MultiDictr) r4r5r6rrprOrrQrrP_url_decode_implr)rr include_emptyr separatorr9rps r(rtrt5s@ MM 0  {-!S*Y"<"<$$W%78 Au  jE&B&B$$W%78  GGI   r'c[R"S[SS9 SSKJn U"XU5n[ XX#5n UcSSKJn U nU"U 5$)aFWorks like :func:`url_decode` but decodes a stream. The behavior of stream and limit follows functions like :func:`~werkzeug.wsgi.make_line_iter`. The generator of pairs is directly fed to the `cls` so you can consume the data while it's parsed. :param stream: a stream with the encoded querystring :param charset: the charset of the query string. If set to `None` no decoding will take place. :param include_empty: Set to `False` if you don't want empty values to appear in the dict. :param errors: the decoding error behavior. :param separator: the pair separator to be used, defaults to ``&`` :param cls: an optional dict class to use. If this is not specified or `None` the default :class:`MultiDict` is used. :param limit: the content length of the URL data. Not necessary if a limited stream is provided. .. deprecated:: 2.3 Will be removed in Werkzeug 2.4. Use ``urllib.parse.parse_qs`` instead. .. versionchanged:: 2.1 The ``decode_keys`` and ``return_iterator`` parameters were removed. .. versionadded:: 0.8 zy'werkzeug.urls.url_decode_stream' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.parse_qs' instead.r1r2r )make_chunk_iterro)r4r5r6wsgirurqrrp) streamrrrrrsr9limitru pair_iterdecoderrps r(url_decode_streamr{ksPF MM > &59Iy=IG {- w<r'c## UHfnU(dM [U5nU"S5nXd;aURUS5upxOU(dMBUnU"S5n[XqU5[XU54v Mh g7f)Nrr r)r rr5) ryrrrrpairrequalrrs r(rqrqsu   &# =E1-JC CbEE S6 2 UV 4  sA.A0c[R"S[SS9 [US5nUR [ XX#55$)aURL encode a dict/`MultiDict`. If a value is `None` it will not appear in the result string. Per default only values are encoded into the target charset strings. :param obj: the object to encode into a query string. :param charset: the charset of the query string. :param sort: set to `True` if you want parameters to be sorted by `key`. :param separator: the separator to be used for the pairs. :param key: an optional function to be used for sorting. For more details check out the :func:`sorted` documentation. .. deprecated:: 2.3 Will be removed in Werkzeug 2.4. Use ``urllib.parse.urlencode`` instead. .. versionchanged:: 2.1 The ``encode_keys`` parameter was removed. .. versionchanged:: 0.5 Added the ``sort``, ``key``, and ``separator`` parameters. zs'werkzeug.urls.url_encode' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.urlencode' instead.r1r2r)r4r5r6r r{r)rrrrrss r( url_encoders@6 MM 1   7+I >>*3C DDr'c[R"S[SS9 [US5n[ XX45nUcU$[ U5H.upxU(aUR U5 UR U5 M0 g)aLike :meth:`url_encode` but writes the results to a stream object. If the stream is `None` a generator over all encoded pairs is returned. :param obj: the object to encode into a query string. :param stream: a stream to write the encoded object into or `None` if an iterator over the encoded pairs should be returned. In that case the separator argument is ignored. :param charset: the charset of the query string. :param sort: set to `True` if you want parameters to be sorted by `key`. :param separator: the separator to be used for the pairs. :param key: an optional function to be used for sorting. For more details check out the :func:`sorted` documentation. .. deprecated:: 2.3 Will be removed in Werkzeug 2.4. Use ``urllib.parse.urlencode`` instead. .. versionchanged:: 2.1 The ``encode_keys`` parameter was removed. .. versionadded:: 0.8 zz'werkzeug.urls.url_encode_stream' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.urlencode' instead.r1r2rN)r4r5r6r r enumeratewrite) rrwrrrrsgenrchunks r(url_encode_streamrso< MM ?   7+I 3 3C ~ n   LL # U% r'cL[R"S[SS9 [U[5(a [ U5n[U[5(a [ U5n[ X45 [U5nU(dU$U(dU$[XS9upEpgn[XU5uppn X:waU$U (a[ XXU 45$Un U SSU"S5:XaU RU"S55nOZU (d!URU"S55nU (dUn O2URU"S55SSU RU"S55-nUSU"S 5:Xa U"S 5US'UVs/sHoU"S 5:wdMUPM nnSn[U5S- nUU:aBUUU"S 5:Xa&UUS- U"S 5U"S 54;a UUS- US-2 OUS- nUU:aMBOM[U"S 5U"S 5/nUSSU:XaUS USSU:XaMU"S5RU5n [ XXU 45$s snf) aUJoin a base URL and a possibly relative URL to form an absolute interpretation of the latter. :param base: the base URL for the join operation. :param url: the URL to join. :param allow_fragments: indicates whether fragments should be allowed. .. deprecated:: 2.3 Will be removed in Werkzeug 2.4. Use ``urllib.parse.urljoin`` instead. zo'werkzeug.urls.url_join' is deprecated and will be removed in Werkzeug 2.4. Use 'urllib.parse.urljoin' instead.r1r2)rNr r.rz..) r4r5r6rOr`r~r r ryrrr{)baserrrbschemebnetlocbpathbquery bfragmentrrrrrsegmentssegmentrnunwanted_markers r(rzrz sI MM / $4 #u#d[!T"A   1: 2.GeY-6cO,T)FD   FDBCC F BQx1S6::af% ;;qv&E;;qv&s+djj3.@@|qvu (0ExGaf3DxHE   MA !e{ag%(1q5/!B%4AQ*QQUQU]+ FA !e  uag&O 2A,/ ) QK 2A,/ ) S6;;x D X> ??%Fs H!1H!cf[U5Vs/sH o"ScM UPM nn[USUS9$s snf)Nr z !$'()*,/:;?@)r$rL)rr)rrLxrs r( _urlencoder\s8)/ D/1Q4Q/E D U( CC Es ..)r)r str | bytesrrrr) r1t.Mapping[str, str] | t.Iterable[tuple[str, str]]rrrboolr+t.Callable[[tuple[str, str]], t.Any] | Nonerzt.Iterator[str])rrrrrr)NT)rrrrrrrr*)rrz/:r) rrrrr$rrrrzt.Callable[[bytes], str]r ) rrrrrrr$rrrrr)rrr) rrrrrrr$rrr)r0ztuple[str, str, str, str, str]rr)rrGr) rrrrrrrrrrr)rrrrrrrr)r)rrrrrr)rBrRrztuple[str, int])rrrUrrz t.Callable[[str, str, str], str]r)rf$str | tuple[str, str, str, str, str]rrrrrr)NNN) rhrrrrrriz bool | Nonerr)rhrrr)rTrG&N)rzt.AnyStrrrrrrrrrsrr9type[ds.MultiDict] | Nonerr)rTrG&NN)rwz t.IO[bytes]rrrrrrrrsrr9rrxrrr) ryzt.Iterable[t.AnyStr]rrrrrrrrzt.Iterator[tuple[str, str]])rFNr) rrrrrrrrrsrrr)NrFNr)rrrwzt.IO[str] | NonerrrrrrrsrrNone)T)rrrrrrrr)rrrLrrr)Mr __future__rcodecsrrRtypingtr4 urllib.parserrrrr _internalr r r r rr TYPE_CHECKINGrdsrSr_always_safe_charsrrPr! _hexdigitsrXrr"r+ NamedTuplerr*rrrr%rrrdryr%_fast_url_quoter)rrr.r~rr5r=rDregister_errorrWrrQ_always_unsafercrbrarerrrmrtr{rqrrrzr)arr,s000r(rs. #  "!#'#+,??&ZZ, - +227;< %    c!IWsaS9b11   :?s D$sn##G, D  fifR  ' 8 w B:Cj8Q 5Q>W :W W W 5 W  W<CBF:= := :=:>:= :=|        >'('S=6  *% *% *% *%  *%  *%  *%\NPQ QQ14QGJQQ.%T && & &  &  &>;D++ +47++@#LL*,BC21t1d1D1299;&z>B#G^f-DE"6>E+AB "6>G+CD ZE -ZE ZE ZE ZE~#' xE -xE xE xE! xE  xEv.%) 33 33  3  3 # 33p%)4 4 44  4  4 # 4 44n # .1 BF PS   .7; "E :"E "E "E 5 "E  "E  "EN $7; , :, ,,  , 5 ,  , ,d!N@ .N@ -N@N@ N@dOVD <DHKDDe) Es #5L&L