U
|
Þ=®ds² ã
|
@ sÒ U d Z ddlmZ ddlZddlZddlZddlZddlZddl m
|
Z
|
ddl m Z ddl m Z ddl m Z ddl mZ d d
|
lmZ d d lmZ d d lmZ d d lmZ d dlmZ ejrÄd dlmZ e d¡ZdZe e d¡Z dZ dd e D Z dd e!dD Z"G dd dej#Z$G dd d e$Z%G d d d e%Z&G d d d e%Z'e e iZ(d!e)d"< dd$d$d%d&d'd(Z*d)d*d+d,d-d.d/d0Z+dd*d*d*d1d2d3Z,dd*d5d+d d6d7d8Z-dd*d*d$d$d<d=d>d?Z.e. Z/e.d@dAdBZ0d%d*dCdDdEZ1dd$d*d*d$d$d*dFdGdHZ2dd*d*d*d*d*dIdJdKZ3dLd*dMdNdOZ4d d$d*d*d*d*dQdRdSZ5d¡d$d*d*d*dTdUdVZ6d¢d*d*d*dWdXdYZ7dZd[d\d]d^Z8e 9d_e8¡ d*d*d`dadbdcZ:e;e!ddd£ <¡ Z=e:dge=Z>e:dhe=di Z?e:dje=dk Z@e:dle=dm ZAd¤dnd5d5d*dodpdqZBd¥dnd5d5drd*dsdtduZCd*d*dvdwdxZDd¦dzd*d+d*d*d{d|d}d~dZEd§dd*d+d*d%d{dd|ddd
ZFdd*d+d*ddddZGd¨d)d*d+d,d*d*dddZHd©d)dd*d+d,d*ddddZIdªdndnd+d*dddZJd«d)d*d*dddZKdS )¬zFunctions 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_str©Úiter_multi_items)Údatastructuresz^[a-zA-Z0-9+-.]+$zKabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~$!'()*+,;ÚasciiÚ0123456789ABCDEFabcdefc C s8 i | ]0}t D ]&}| | d ¡t| | dq qS )r é )Ú
|
_hexdigitsÚencodeÚint)Ú.0ÚaÚb© r úDd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/urls.pyÚ
|
<dictcomp>* s
|
þ r c C s g | ]}d |d d¡qS )ú%Ú02Xr )r )r Úcharr r r Ú
|
<listcomp>/ s r é c @ s6 e Zd ZU ded< ded< ded< ded< ded< dS )Ú _URLTupleÚstrÚschemeÚnetlocÚpathÚqueryÚfragmentN)Ú__name__Ú
|
__module__Ú __qualname__Ú__annotations__r r r r r! 2 s
|
|
r! c s¤ e Zd ZU dZdZded< ded< ded< ded< ddd d fd
|
d Zdd d dZdd dddZe dd ddZ
|
e dd ddZ e dd ddZ e dd ddZ e dd d d Ze dd d d Ze dd d d!Ze dd d"d#Zddd$d d%d&Zddd d d'd(Zdd d)d*Zdd d+d,Zdd d-d.Zd d d/d0Zd d d1d2Zd?dd4d5d6d7Zd8d d9d:Zd4d d;d<Zd4d d=d>Z Z S )@ÚBaseURLz¨Superclass 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Ú _rbracketzt.Any)ÚargsÚkwargsÚreturnc s. t jd| j dtdd t j| f||S )Nz'werkzeug.urls.z\' is deprecated and will be removed in Werkzeug 3.0. Use the 'urllib.parse' library instead.é ©Ú
|
stacklevel)ÚwarningsÚwarnr( ÚDeprecationWarningÚsuperÚ__new__)Úclsr1 r2 ©Ú __class__r r r; G s üzBaseURL.__new__©r3 c C s | ¡ S ©N)Úto_url©Úselfr r r Ú__str__P s zBaseURL.__str__)r2 r3 c K s | j f |S )zReturn an URL with the same values, except for those parameters
|
given new values by whichever keyword arguments are specified.)Ú_replace)rC r2 r r r ÚreplaceS s zBaseURL.replaceú
|
str | Nonec C s | ¡ d S )z¹The 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_hostrB r r r ÚhostX s z BaseURL.hostc C sF | j }|dk rBt|trBz| d¡ d¡}W n tk
|
r@ Y nX |S )a Works 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.
|
NÚidnar )rI Ú
|
isinstancer" r ÚdecodeÚ UnicodeError©rC Úrvr r r Ú
|
ascii_host` s zBaseURL.ascii_hostú
|
int | Nonec C sT z6t t| ¡ d }d| kr*dkr4n n|W S W n ttfk
|
rN Y nX dS )z}The port in the URL as an integer if it was present, `None`
|
otherwise. This does not fill in default ports.
|
r r iÿÿ N)r r rH Ú
|
ValueErrorÚ TypeErrorrN r r r Úporto s
|
z BaseURL.portc C s | ¡ d S )zSThe authentication part in the URL if available, `None`
|
otherwise.
|
r )Ú _split_netlocrB r r r Úauth| s z BaseURL.authc C s | ¡ d }|dk r t|S dS )zThe username if it was part of the URL, `None` otherwise.
|
This undergoes URL decoding and will always be a string.
|
r N©Ú _split_authÚ_url_unquote_legacyrN r r r Úusername s zBaseURL.usernamec C s | ¡ d S )zThe username if it was part of the URL, `None` otherwise.
|
Unlike :attr:`username` this one is not being decoded.
|
r ©rX rB r r r Ú raw_username s zBaseURL.raw_usernamec C s | ¡ d }|dk r t|S dS )zThe password if it was part of the URL, `None` otherwise.
|
This undergoes URL decoding and will always be a string.
|
r NrW rN r r r Úpassword s zBaseURL.passwordc C s | ¡ d S )zThe password if it was part of the URL, `None` otherwise.
|
Unlike :attr:`password` this one is not being decoded.
|
r r[ rB r r r Ú raw_password s zBaseURL.raw_passwordúds.MultiDict[str, str]c O s t | jf||S )zØDecodes 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_decoder& ©rC r1 r2 r r r Ú decode_query¥ s zBaseURL.decode_queryc O s t t| f||S )z©Joins 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_parseÚurl_joinra r r r Újoin¬ s z BaseURL.joinc C s t | S )zºReturns 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_unparserB r r r rA ³ s zBaseURL.to_urlc
|
C s | j pd}d|kr d| d}| j}|dk r:| d| }d tdt| jpLddddt| jp^ddddg¡}|r| d | }|S )
|
z6Encodes the netloc part to an ASCII safe URL as bytes.Ú ú:ú[ú]Núutf-8Ústrictz/:%ú@)rP rT re ÚfilterÚ url_quoter\ r^ )rC rO rT rV r r r Ú encode_netlocº s"
|
þþÿ zBaseURL.encode_netlocc C s | j pd}t|tr | ¡ }t|}d|kr8d| d}| j}|dk rT| d| }d tdt| j pfddt| j
|
ptddg¡}|r| d| }|S )z&Decodes the netloc part into a string.rg rh ri rj Nz/:%@rm ) rI rK ÚbytesrL r
|
rT re rn rY r\ r^ )rC rI rO rT rV r r r Ú decode_netlocÏ s(
|
|
þþÿ zBaseURL.decode_netlocc C s t t| S )a* Returns 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.
|
)rc Ú
|
iri_to_urirB r r r Ú to_uri_tupleê s zBaseURL.to_uri_tuplec C s t t| S )aS 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.
|
)rc Ú
|
uri_to_irirB r r r Ú to_iri_tupleô s zBaseURL.to_iri_tupleNz tuple[str | None, str | None])Ú
|
pathformatr3 c C s: | j dkrdS t| j}| jp d}|dkr>tjdkr:d}nd}|dkrø|dd
dkr|dd
¡ r|d d
|
d kr|dd
d |d
|
d
}|dd
|
d k}ddl}| |¡}|rö|dkrö| d¡
|
dd¡}t |d krê|\}}n |d }d}n,|dkrddl }| |¡}nt d||dkr2d}||fS )a@ Returns 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.
|
Úfile©NNNÚntZwindowsÚposixr ú/r4 é z|:rh )z\\\z///r ú\rg zInvalid path format )z 127.0.0.1z::1Ú localhost)r# Ú url_unquoter% r$ ÚosÚnameÚisalphaÚntpathÚnormpathÚlstripÚsplitÚlenÚ posixpathrS )rC rw r% rI Z windows_sharer Úpartsr r r r Úget_file_locationÿ s6
|
|
|
|
0
|
|
|
|
zBaseURL.get_file_locationztuple[str | None, str]c C s2 | j | jkr(| j | j ¡\}}}||fS d | jfS r@ )r- r$ Ú partition)rC rV Ú_r$ r r r rU = s zBaseURL._split_netlocc C s@ | ¡ d }|sdS | j|kr&|d fS | | j¡\}}}||fS )Nr ry )rU r. r )rC rV rZ r r] r r r rX C s
|
zBaseURL._split_authc C s¨ | ¡ d }|sdS | | j¡sL| j|krD| | j¡\}}}||fS |d fS | | j¡}|dk rh|d fS |d|
}||d d
}| | j¡r ||dd
fS |d fS )Nr ry r )rU Ú
|
startswithr/ r. r Úfindr0 )rC rO rI r rT ÚidxÚrestr r r rH M s
|
zBaseURL._split_host)N) r( r) r* Ú__doc__Ú __slots__r+ r; rD rF ÚpropertyrI rP rT rV rZ r\ r] r^ rb re rA rp rr rt rv r rU rX rH Ú __classcell__r r r= r r, : sJ
|
|
ÿ>
|
r, c @ s8 e Zd ZdZdZdZdZdZdZdd d d
|
d d d Z dS )ÚURLzÿRepresents 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 rm rh ri rj rk rF r" ÚBytesURL©ÚcharsetÚerrorsr3 c C s: t | j d¡| ¡ | j ||¡| j ||¡| j ||¡S )zEncodes the URL to a tuple made out of bytes. The charset is
|
only being used for the path, query and fragment.
|
r )r r# r rp r% r& r' ©rC r r r r r r r s
|
ûz
|
URL.encodeN)rk rF )
|
r( r) r* r r r- r. r/ r0 r r r r r r c s r c @ sT e Zd ZdZdZdZdZdZdZddd d
|
Z d dd d Z
|
dddddddZ dS )r zRepresents a parsed URL in bytes.
|
|
.. deprecated:: 2.3
|
Will be removed in Werkzeug 3.0. Use the ``urllib.parse`` library instead.
|
r ó @ó :ó [ó ]r" r? c C s | ¡ dd¡S )Nrk rF )rA rL rB r r r rD s zBytesURL.__str__rq c C s | j S )z&Returns the netloc unchanged as bytes.)r$ rB r r r rp s zBytesURL.encode_netlocrk rF r r c C s: t | j d¡| ¡ | j ||¡| j ||¡| j ||¡S )zDecodes the URL to a tuple made out of strings. The charset is
|
only being used for the path, query and fragment.
|
r )r r# rL rr r% r& r' r r r r rL s
|
ûzBytesURL.decodeN)rk rF ) r( r) r* r r r- r. r/ r0 rD rp rL r r r r r s r z&dict[frozenset[int], dict[bytes, int]]Ú _unquote_mapsrg z str | bytesrq )ÚstringÚunsafer3 c sì t | tr| d¡} t tr( d¡ tt t| d¡}tt|d}z t }W n2 t k
|
r fddt
|
¡ D }t < Y nX |D ]N}|d d
}||krÎ| || ¡ | |dd
¡ q| d¡ | |¡ qt|S )Nrk ó %ó c s i | ]\}}| kr||qS r r )r Úhr ©r¢ r r r ± s z%_unquote_to_bytes.<locals>.<dictcomp>r4 é% )rK r" r Ú frozensetÚ bytearrayÚiterr Únextr ÚKeyErrorÚ
|
_hextobyteÚitemsÚappendÚextendrq )r¡ r¢ ÚgroupsÚresultZ hex_to_byteÚgroupÚcoder r¦ r Ú_unquote_to_bytes£ s*
|
|
|
|
|
ÿ
|
rµ z1t.Mapping[str, str] | t.Iterable[tuple[str, str]]r" Úboolz+t.Callable[[tuple[str, str]], t.Any] | Nonezt.Iterator[str])Úobjr ÚsortÚkeyr3 c
|
c s ddl m} || }|r$t||d}|D ]f\}}|d kr:q(t|tsTt| |¡}n|}t|tsrt| |¡} n|} t| dt| V q(d S )Nr r )r¹ ú=)r r ÚsortedrK rq r" r Ú_fast_url_quote_plus)
|
r· r r¸ r¹ r ÚiterableZkey_strZ value_strÚ key_bytesZ value_bytesr r r Ú_url_encode_impl s
|
|
r¿ )Úvaluer¢ r3 c C s: zt | dd|dW S tk
|
r4 t | d|d Y S X d S )Nrk rl )r r r¢ Úlatin1)r r¢ )r rM )rÀ r¢ r r r rY à s rY TrG )Úurlr# Úallow_fragmentsr3 c s¾ t jdtdd t| t| t}|dkr2 d} d } }}| d¡}|dkr²t t | d|
dd ¡r²| |d
|
d
}|rt
|
fd d |D r²| d|
¡ | }} | dd
d krVt | } dD ]"}
|
| |
|
d¡} | dkrØt | | } qØ| d|
| | d
}} d|kr2 d|ksN d|krV d|krVtd|r~ d| kr~| dd
|
¡\} } d| kr | dd
|
¡\} }|rªtnt} | ||| ||S )a Parses a URL from a string into a :class:`URL` tuple. If the URL
|
is lacking a scheme it can be provided as second argument. Otherwise,
|
it is ignored. Optionally fragments can be stripped from the URL
|
by setting `allow_fragments` to `False`.
|
|
The inverse of this function is :func:`url_unparse`.
|
|
:param url: the URL to parse.
|
:param scheme: the default schema to use if the URL is schemaless.
|
:param allow_fragments: if set to `False` a fragment will be removed
|
from the URL.
|
|
.. deprecated:: 2.3
|
Will be removed in Werkzeug 3.0. Use ``urllib.parse.urlsplit`` instead.
|
zq'werkzeug.urls.url_parse' is deprecated and will be removed in Werkzeug 3.0. Use 'urllib.parse.urlsplit' instead.r4 r5 Nrg rh r rF )r r c 3 s | ]}| d kV qdS )Ú
|
0123456789Nr ©r Úc©Úsr r Ú <genexpr>
|
s z url_parse.<locals>.<genexpr>ú//ú/?#ri rj zInvalid IPv6 URLú#ú?)r7 r8 r9 r rK r" r Ú
|
_scheme_reÚmatchr ÚanyÚlowerr ÚminrR r r r ) r r# rà Z is_text_basedr$ r& r' Úir ÚdelimrÆ ÚwdelimZ result_typer rÇ r rc ç sD ü
|
"
|
ÿ
|
ÿrc rk rl ú/:zt.Callable[[bytes], str])r r Úsafer¢ r3 c sv t tr | |¡ t |tr,| | |¡}tt tB tt| fddtdD dddfdd }|S ) a£ Precompile the translation table for a URL encoding function.
|
|
Unlike :func:`url_quote`, the generated function only takes the
|
string to quote.
|
|
:param charset: The charset to encode the result with.
|
:param errors: How to handle encoding errors.
|
:param safe: An optional sequence of safe characters to never encode.
|
:param unsafe: An optional sequence of unsafe characters to always encode.
|
c s( g | ] }| krt |n
|
d |dqS )r r )ÚchrrÅ ©r× r r r ; s z(_make_fast_url_quote.<locals>.<listcomp>r rq r" ©r¡ r3 c s d fdd| D ¡S )Nrg c s g | ] } | qS r r rÅ ©Útabler r r > s z7_make_fast_url_quote.<locals>.quote.<locals>.<listcomp>)re ©r¡ rÛ r r r = s z#_make_fast_url_quote.<locals>.quote)rK r" r r¨ r© Ú _always_safeÚrange)r r r× r¢ r r )r× rÜ r Ú_make_fast_url_quote$ s
|
|
rà ú ú+)r× r¢ rÚ c C s t | dd¡S )Nrá râ )Ú_fast_quote_plusrF rÝ r r r r¼ G s r¼ )r¡ r r r× r¢ r3 c C sÊ t jdtdd t| tttfs(t| } t| tr>| ||¡} t|trT| ||¡}t|trj| ||¡}tt|t B tt| }t }t| D ]&}||kr¬|
|
|¡ q| t | ¡ qt| |¡S )aª URL 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.r4 r5 )r7 r8 r9 rK r" rq r© r r¨ rÞ r¯ r° Ú
|
_bytetohexrL )r¡ r r r× r¢ rO r r r r ro K s( ü
|
|
|
ro )r¡ r r r× r3 c C s, t jdtdd t| |||d d dd¡S )aO URL 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.r4 r5 rá râ )r7 r8 r9 ro rF )r¡ r r r× r r r Úurl_quote_plusx s ürå z tuple[str, str, str, str, str])Ú
|
componentsr3 c C sÖ t jdtdd t| | \}}}}}t|}|d}|sL|r| |d¡r|rp|dd
|dkrp|d| }|d|p|d | }n |r||7 }|rª||d | }|r¾||d
|
| }|rÒ||d | }|S ) ai The 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.r4 r5 rg r| Nr rÊ rh rÍ rÌ )r7 r8 r9 r r r )ræ r# r$ r% r& r' rÈ r r r r rf s,
|
ü rf rF )rÈ r r r¢ r3 c C s2 t jdtdd t| |}|dkr&|S | ||¡S )aÎ URL 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.r4 r5 N)r7 r8 r9 rµ rL )rÈ r r r¢ rO r r r r · s ü
|
r )rÈ r r r3 c C s@ t jdtdd t| tr(| dd¡} n | dd¡} t| ||S )a& URL 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.r4 r5 râ rá ó +ó )r7 r8 r9 rK r" rF r )rÈ r r r r r Úurl_unquote_plusÕ s ü
|
ré )rÈ r r3 c C s° t jdtdd t| |d dd¡} | d¡r`| dd
¡ r`| d d
|
d kr`d | dd
} t| }t|j |dd}t
|
|j |dd}t
|
|j |dd}t |j| ¡ |||fS )aF Sometimes 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.r4 r5 rF r~ r| zfile://é é é
|
)z:/z|/zfile:///Nz
|
/%+$!*'(),rÙ z :&%=+$!*'(),)r7 r8 r9 r rF r r rc ro r% rå r& r' rf r# rp )rÈ r r r% ÚqsÚanchorr r r Úurl_fixõ s ý*rï rM ztuple[str, int])Úer3 c C s$ t | j| j| j
dd}|| jfS )zRUsed in :func:`uri_to_iri` after unquoting to re-quote any
|
invalid bytes.
|
rg rÙ )r ÚobjectÚstartÚend)rð Úoutr r r Ú_codec_error_url_quote s rõ úwerkzeug.url_quotez t.Callable[[str, str, str], str])r Úcharsr3 c sV d dd t|D ¡}t d| dtj¡ ddddd fdd }d
|
| |_|S ) zÑCreate 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.
|
ú|c s s | ]}t |d V qdS )r N)ÚordrÅ r r r rÉ - s z%_make_unquote_part.<locals>.<genexpr>z((?:%(?:z))+)r" )rÀ Úencodingr r3 c sH t | ¡}g }|D ]&}| t|||¡ | t|d¡ qd |¡S )Nrg )rª r r¯ r r« re )rÀ rú r r rô Úpart©Úpatternr r Ú_unquote_partial0 s z,_make_unquote_part.<locals>._unquote_partialZ _unquote_)re r» ÚreÚcompileÚIr( )r r÷ Úchoicesrþ r rü r Ú_make_unquote_part( s
|
|
r é! r§ é r' r& z&=+#r% rË Úuserz:@/?#z$str | tuple[str, str, str, str, str])Úurir r r3 c C sJ t | tr"tjdtdd t| } t | trDtjdtdd | ¡ } |dk r^tjdtdd nd}|dk r|tjdtdd nd }t| }t |j
|
||}t |j ||}t |j||}|jrÄt|j}nd
|
}d |krÜd | d }|jrò| d |j }|jr6t|j||}|jr(| d t|j|| }| d| }t|j||||fS )a Convert 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.r4 r5 úFPassing bytes is deprecated and will not be supported in Werkzeug 3.0.NúJThe 'charset' parameter is deprecated and will be removed in Werkzeug 3.0.rk úIThe 'errors' parameter is deprecated and will be removed in Werkzeug 3.0.rö rg rh ri rj rm )rK Útupler7 r8 r9 r rq rL r Ú _unquote_pathr% Ú_unquote_queryr& Ú_unquote_fragmentr' Úhostnamer
|
rT rZ Ú _unquote_userr] r# ) r r r r r% r& r' r$ rV r r r ru H sZ
|
ý
|
ýüý ru z bool | None)Úirir r Úsafe_conversionr3 c C sÀ |dk rt jdtdd nd}t| tr@t jdtdd t| } t| trdt jdtdd | |¡} |dk r~t jdtdd nd }|dk rt jd
|
tdd |rØz$| d ¡}t |
|
¡ d krÀ| W S W n t k
|
rÖ Y nX t | }t |jd ||d}t |jd||d}t |jd||d}|jr2|j d¡ d ¡} nd} d| krLd| d} |jrd| d|j } |jr¬t |jdd}
|
|jrt |jdd} |
|
d| }
|
|
|
d| } t|j| |||fS )a Convert 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
|
Nr
|
r4 r5 rk r r r rl zRThe 'safe_conversion' parameter is deprecated and will be removed in Werkzeug 3.0.r r z%!$&'()*+,/:;=@)r× rú r z%!$&'()*+,/:;=?@z%!#$&'()*+,/:;=?@rJ rg rh ri rj z %!$&'()*+,;=rÙ rm )r7 r8 r9 rK r r rq rL r r r rM r r r% r& r' r rT rZ r] r# ) r r r r Z ascii_irir r% r& r' r$ rV Z pass_quotedr r r rs ¥ s $ü
|
ý
|
ý
|
ýü
|
|
ÿ
|
rs )r r3 c C sD z| d¡ W n tk
|
r" Y nX t| dd¡dkr<| S t| S )aØ The 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:
|
r Nr )r rM r r rs )r r r r Ú_invalid_iri_to_uri s
|
r ú&zt.AnyStrztype[ds.MultiDict] | Noner_ )rÈ r Ú include_emptyr Ú separatorr< r3 c C s t jdtdd |dkr(ddlm} |}t| trLt|tsL| |pFd¡}n"t| trnt|tsn| |pjd¡}|t
|
| |¡|||S )a² Parse 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.r4 r5 Nr ©Ú MultiDictr ) r7 r8 r9 r r rK r" rL rq r Ú_url_decode_implr )rÈ r r r r r< r r r r r` 5 s( ü ÿÿr` ó &z t.IO[bytes]rQ )Ústreamr r r r r< Úlimitr3 c C sV t jdtdd ddlm} || ||}t||||} |dkrNddlm}
|
|
|
}|| S )a Works 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.r4 r5 r )Úmake_chunk_iterNr )r7 r8 r9 Zwsgir r r r ) r r r r r r< r r Ú pair_iterÚdecoderr r r r Úurl_decode_streamk s #ü r! zt.Iterable[t.AnyStr]zt.Iterator[tuple[str, str]])r r r r r3 c c sj | D ]`}|sqt |}|d}||kr8| |d¡\}}n|s>q|}|d}t|||t|||fV qd S )Nrº r rg )r r ré ) r r r r ÚpairrÈ Úequalr¹ rÀ r r r r ¢ s
|
|
þr F)r· r r¸ r¹ r r3 c C s. t jdtdd t|d}| t| |||¡S )aP URL 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.r4 r5 r )r7 r8 r9 r re r¿ )r· r r¸ r¹ r r r r Ú
|
url_encode· s ü
|
r$ zt.IO[str] | NoneÚNone)r· r r r¸ r¹ r r3 c C sb t jdtdd t|d}t| |||}|dkr4|S t|D ] \}}|rR| |¡ | |¡ q<dS )aË Like :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.r4 r5 r N)r7 r8 r9 r r¿ Ú enumerateÚwrite) r· r r r¸ r¹ r Úgenr Úchunkr r r Úurl_encode_streamÜ s ü
|
|
r* )Úbaser rà r3 c sþ t jdtdd t| tr"t| } t|tr4t|}t| |f t| | sP|S |sX| S t| |d\}}}}}t|||\}} }
|
} } ||kr|S | r¦t|| |
|
| | fS |} |
|
dd
dkrÎ|
|
d¡} n@|
|
sê| d¡} | sè|} n$| d¡dd
|
|
d¡ } | d d kr, d
|
| d< fd d | D } d}t
|
| d }||k r²| | d kr| |d d
|
d fkr| |d |d
= q>|d7 }qNq²q> d
|
d g}| dd
|krÞ| d= q d | ¡}
|
t|| |
|
| | fS )aq Join 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.r4 r5 )rà Nr r| éÿÿÿÿÚ.rg c s g | ]}| d kr|qS )r- r )r ÚsegmentrÇ r r r G s z url_join.<locals>.<listcomp>z..) r7 r8 r9 rK r rf r r rc r r re )r+ r rà ÚbschemeÚbnetlocÚbpathÚbqueryÚ bfragmentr# r$ r% r& r' ÚsegmentsrÓ ÚnZunwanted_markerr rÇ r rd s` ü
|
|
ÿ$
|
0
|
rd )r& rú r3 c C s dd t | D }t|d|dS )Nc S s g | ]}|d dk r|qS )r Nr )r Úxr r r r _ s z _urlencode.<locals>.<listcomp>z !$'()*,/:;?@)r× rú )r r )r& rú r® r r r Ú
|
_urlencode\ s r7 )rg )rg )NT)rk rl rÖ rg )rk rl rÖ rg )rk rl rg )rk rF rg )rk rF )rk )r§ r )NN)NNN)rk TrF r N)rk TrF r NN)rk FNr )Nrk FNr )T)rk )Lr Ú
|
__future__r Úcodecsr rÿ ÚtypingÚtr7 Ú urllib.parser r r r r Ú _internalr r
|
r r r r Ú TYPE_CHECKINGrg Zdsr rÎ Z_always_safe_charsr¨ r rÞ r r rß rä Ú
|
NamedTupler! r, r r r r+ rµ r¿ rY rc rà Z_fast_url_quoterã r¼ ro rå rf r ré rï rõ Úregister_errorr rq rL Z_always_unsafer r r r ru rs r r` r! r r$ r* rd r7 r r r r Ú<module> sÞ
|
ÿþ + ! ÿ> ü û. ÿ* ü ÿ &
|
|
ý_ ü{ ú 8 ù 7 û' ú 2 ýR ÿ
|
