B LJb @s8UdZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z ej rtdd l mZed Zeed Zd Zd deDZddedDZGdddejZGdddeZGdddeZGdddeZeeiZejej e!eje"e!ffe#d<dlej$e%e"fej$e%e"fe"dddZ&ej$ej'e%e%fej(ej)e%e%ffe%e*ej+ej,ej)e%e%fgej-fej.e%dd d!Z/dme%e%e%d"d#d$Z0dne%ej+e%e*ed&d'd(Z1doe%e%ej$e%e"fej$e%e"fej,e"ge%fd,d-d.Z2e2Z3e2d/d0d1Z4e"e%d2d3d4Z5dpej$e%e"fe%e%ej$e%e"fej$e%e"fe%d5d6d7Z6dqe%e%e%e%e%d8d9d:Z7ej)e%e%e%e%e%fe%d;dej)e%e!fdJdKdLZ?e@dMe?duej$e%ej)e%e%e%e%e%ffe%e%e%dNdOdPZAdQZBdvej$e%ej)e%e%e%e%e%ffe%e%e*e%dSdTdUZCdwejDe%e*e%e%ej+ejEdWdXdYdZd[ZFdxejGe"e%e*e%e"ej+ejEdWej+e!dXd]d^d_ZHej(ejDe%e*e%ej.ej)e%e%fd`dadbZIdyej$ej'e%e%fej(ej)e%e%ffe%e*ej+ej,ej)e%e%fgej-fe%e%dcdddeZJdzej$ej'e%e%fej(ej)e%e%ffej+ejGe%e%e*ej+ej,ej)e%e%fgej-fe%ddfdgdhZKd{ej$e%ej)e%e%e%e%e%ffej$e%ej)e%e%e%e%e%ffe*e%didjdkZLdS)|zFunctions for working with URLs. Contains implementations of functions from :mod:`urllib.parse` that handle bytes and strings. N)_check_str_tuple) _decode_idna) _encode_idna)_make_encode_wrapper)_to_str)datastructuresz^[a-zA-Z0-9+-.]+$sKabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~$!'()*+,;0123456789ABCDEFabcdefcCs8i|]0}tD]&}t||d||dq qS)ascii) _hexdigitsintencode).0abra/var/www/downstreamdata.science/rtclock/rtclock-venv/lib/python3.7/site-packages/werkzeug/urls.py #srcCsg|]}d|ddqS)%02Xr )r)rcharrrr (src@s6eZdZUeed<eed<eed<eed<eed<dS) _URLTupleschemenetlocpathqueryfragmentN)__name__ __module__ __qualname__str__annotations__rrrrr+s rc@seZdZUdZdZeed<eed<eed<eed<eddd Zej dd d d Z e ej edd dZ e ej edddZe ej edddZe ej edddZe ej edddZe ej edddZe ej edddZe ej edddZej ej dddd Zej ej ddd!d"Zedd#d$Zedd%d&Zedd'd(Zddd)d*Zddd+d,Zd7ej eejej eej efd.d/d0Zejej eefdd1d2Zejej eej efdd3d4Z ejej eej efdd5d6Z!d-S)8BaseURLz7Superclass of :py:class:`URL` and :py:class:`BytesURL`.r_at_colon _lbracket _rbracket)returncCs|S)N)to_url)selfrrr__str__<szBaseURL.__str__)kwargsr*cKs |jf|S)zReturn an URL with the same values, except for those parameters given new values by whichever keyword arguments are specified.)_replace)r,r.rrrreplace?szBaseURL.replacecCs |dS)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_host)r,rrrhostDsz BaseURL.hostcCsR|j}|dk rFt|trFy t|}Wn tk rD|dd}YnXt|ddS)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. Nr ignore)r2 isinstancer#r UnicodeErrorrr)r,rvrrr ascii_hostLs zBaseURL.ascii_hostc CsRy4tt|d}d|kr*dkr2nn|SWnttfk rLYnXdS)z}The port in the URL as an integer if it was present, `None` otherwise. This does not fill in default ports. rriN)r rr1 ValueError TypeError)r,r6rrrport[sz BaseURL.portcCs |dS)zSThe authentication part in the URL if available, `None` otherwise. r) _split_netloc)r,rrrauthhsz BaseURL.authcCs |d}|dk rt|SdS)zThe 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_legacy)r,r6rrrusernameos zBaseURL.usernamecCs |dS)zThe username if it was part of the URL, `None` otherwise. Unlike :attr:`username` this one is not being decoded. r)r=)r,rrr raw_usernameyszBaseURL.raw_usernamecCs |d}|dk rt|SdS)zThe password if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a string. rN)r=r>)r,r6rrrpasswords zBaseURL.passwordcCs |dS)zThe password if it was part of the URL, `None` otherwise. Unlike :attr:`password` this one is not being decoded. r)r=)r,rrr raw_passwordszBaseURL.raw_passwordzds.MultiDict[str, str])argsr.r*cOst|jf||S)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_decoder)r,rCr.rrr decode_queryszBaseURL.decode_querycOstt|f||S)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_join)r,rCr.rrrjoinsz BaseURL.joincCst|S)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_unparse)r,rrrr+szBaseURL.to_urlc Cs|jpd}d|krd|d}|j}|dk r:|d|}dtdt|jpLddddt|jp^ddddg}|r|d |}|S) z6Encodes the netloc part to an ASCII safe URL as bytes.:[]Nzutf-8strictz/:%@)r7r:rHfilter url_quoter@rB)r,r6r:r<rrr encode_netlocs  zBaseURL.encode_netloccCst|jp d}d|kr"d|d}|j}|dk r>|d|}dtdt|jpPddt|jp^ddg}|r||d|}|S)z&Decodes the netloc part into a string.rJrKrLrMNz/:%@rO)rr2r:rHrPr>r@rB)r,r6r:r<rrr decode_netlocs zBaseURL.decode_netloccCs tt|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. )rF iri_to_uri)r,rrr to_uri_tupleszBaseURL.to_uri_tuplecCs tt|S)aSReturns 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. )rF uri_to_iri)r,rrr to_iri_tuples zBaseURL.to_iri_tupleN) pathformatr*cCs:|jdkrdSt|j}|jp d}|dkr>tjdkr:d}nd}|dkr|dddkr|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)NNNntwindowsposixr/z|:rK)z\\\z///r\rJzInvalid path format )z 127.0.0.1z::1 localhost)r url_unquoterrosnameisalphantpathnormpathlstripsplitlen posixpathr9)r,rXrr2Z windows_sharerfpartsrkrrrget_file_locations6    0       zBaseURL.get_file_locationcCs2|j|jkr(|j|j\}}}||fSd|jfS)N)r&r partition)r,r<_rrrrr;$s zBaseURL._split_netloccCs@|d}|sdS|j|kr&|dfS||j\}}}||fS)Nr)NN)r;r'rn)r,r<r?rorArrrr=*s  zBaseURL._split_authcCs|d}|sdS||jsL|j|krD||j\}}}||fS|dfS||j}|dkrh|dfS|d|}||dd}||jr||ddfS|dfS)Nr)NNr)r; startswithr(r'rnfindr))r,r6r2ror:idxrestrrrr14s       zBaseURL._split_host)N)"r r!r"__doc__ __slots__r#r$r-tAnyr0propertyOptionalr2r7r r:r<r?r@rArBrErHr+rRrSrUrWTuplermr;r=r1rrrrr%3sH      $<$ r%c@s8eZdZdZdZdZdZdZdZde e d d d d Z d S)URLzRepresents a parsed URL. This behaves like a regular tuple but also has some extra attributes that give further insight into the URL. rrOrKrLrMutf-8r0BytesURL)charseterrorsr*c Cs:t|jd||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}rrrRrrr)r,r~rrrrrVs    z URL.encodeN)r|r0) r r!r"rtrur&r'r(r)r#rrrrrr{Jsr{c@sTeZdZdZdZdZdZdZdZe ddd Z e dd d Z de e ddddZ dS)r}z!Represents a parsed URL in bytes.r@:[])r*cCs|ddS)Nzutf-8r0)r+decode)r,rrrr-lszBytesURL.__str__cCs|jS)z&Returns the netloc unchanged as bytes.)r)r,rrrrRoszBytesURL.encode_netlocutf-8r0r{)r~rr*c Cs:t|jd||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{rrrSrrr)r,r~rrrrrss    zBytesURL.decodeN)rr0)r r!r"rtrur&r'r(r)r#r-bytesrRrrrrrr}csr} _unquote_mapsrJ)stringunsafer*cst|tr|d}ttr(dttt|d}tt|d}y t}Wn2t k rfddt D}t<YnXxV|D]N}|dd}||kr| ||| |ddq| d| |qWt|S)Nzutf-8%csi|]\}}|kr||qSrr)rhr)rrrrsz%_unquote_to_bytes..r^%)r4r#r frozenset bytearrayiterrinextrKeyError _hextobyteitemsappendextendr)rrgroupsresultZ hex_to_bytegroupcoder)rr_unquote_to_bytess(          r)objr~sortkeyr*c csddlm}||}|r$t||d}xn|D]f\}}|dkrsr>T)urlrallow_fragmentsr*c st|t|t}|dkr"d}d}}}|d}|dkrtt|d|ddr||dd}|rtfdd |Dr|d||}}|dd d krJt |} x.d D]"} || d } | dkrt | | } qW|d | || d}}d |kr&d|ksBd|krJd |krJt d|rrd|krr| dd\}}d|kr| dd\}}|rt nt} | |||||S)aParses 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. NrJrKrr0)rrc3s|]}|dkVqdS) 0123456789Nr)rc)srr szurl_parse..r^z//z/?#rLrMzInvalid IPv6 URL#?)rr4r#rq _scheme_rematchranylowerrjminr8rir{r}) rrrZ is_text_basedrrrirsdelimrwdelimZ result_typer)rrrFs4 " rFutf-8rN/:)r~rsaferr*csvttr||t|tr,|||}tttBtt|fddtdDttdfdd }|S)aPrecompile 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. cs(g|] }|krt|n d|dqS)rr)chr)rr)rrrrsz(_make_fast_url_quote..r)rr*csdfdd|DS)NrJcsg|] }|qSrr)rr)tablerrrsz7_make_fast_url_quote..quote..)rH)r)rrrquotesz#_make_fast_url_quote..quote)r4r#rrr _always_saferanger)r~rrrrr)rrr_make_fast_url_quotes    r +)rr)rr*cCst|ddS)Nrr)_fast_quote_plusr0)rrrrrsr)rr~rrrr*cCst|tttfst|}t|tr.|||}t|trD|||}t|trZ|||}tt|tBtt|}t}x2t|D]&}||kr||q|t |qWt| |S)aDURL 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. .. versionadded:: 0.9.2 The `unsafe` parameter was added. ) r4r#rrrrrrr _bytetohexr)rr~rrrr6rrrrrQ#s       rQ)rr~rrr*cCst||||ddddS)zURL 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. rr)rQr0)rr~rrrrrurl_quote_plusFs r) componentsr*cCst||\}}}}}t|}|d}|s<|rz||drz|r`|dd|dkr`|d|}|d|pp|d|}n |r||7}|r||d|}|r||d|}|r||d|}|S) zThe 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. rJr]Nrz//rKrr)rrrp)rrrrrrrrrrrrISs" rIr0)rr~rrr*cCs"t||}|dkr|S|||S)afURL 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. N)rr)rr~rrr6rrrrbrs rb)rr~rr*cCs0t|tr|dd}n |dd}t|||S)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. rr+ )r4r#r0rb)rr~rrrrurl_unquote_pluss  r)rr~r*cCst||ddd}|drP|ddrP|dddkrPd |dd }t|}t|j|d d }t|j|d d }t|j |d d }t |j | |||fS)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. r0r`r]zfile:// )z:/z|/zfile:///Nz /%+$!*'(),)rz :&%=+$!*'(),) rr0rprerFrQrrrrrIrrR)rr~rrqsanchorrrrurl_fixs*rcCsg|]}|tkrt|qSr)rr)rrrrrrs)er*cCs t|j|j|j}||jfS)zRUsed in :func:`uri_to_iri` after unquoting to re-quote any invalid bytes. )_fast_url_quoteobjectstartend)routrrr_codec_error_url_quotesrwerkzeug.url_quote)urir~rr*cCsht|trt|}tt||}t|j||t}t|j||t}t|j ||t}t|j | |||fS)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:: 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 ) r4tuplerIrFrrbr_to_iri_unsaferrrrS)rr~rrrrrrrrVs rVz:/?#[]@!$&'()*+,;=%F)irir~rsafe_conversionr*c Cst|trt|}|rVy*t|}|d}t|dkr>|SWntk rTYnXtt|||}t |j ||t }t |j ||t }t |j ||t }t|j||||fS)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``. :param safe_conversion: Return the URL unchanged if it only contains ASCII characters and no whitespace. See the explanation below. There is a general problem with IRI conversion with some protocols that are in violation of the URI specification. Consider the following two IRIs:: magnet:?xt=uri:whatever itms-services://?action=download-manifest After parsing, we don't know if the scheme requires the ``//``, which is dropped if empty, but conveys different meanings in the final URL if it's present or not. In this case, you can use ``safe_conversion``, which will return the URL unchanged if it only contains ASCII characters and no whitespace. This can result in a URI with unquoted characters if it was not already quoted correctly, but preserves the URL's semantics. Werkzeug uses this for the ``Location`` header for redirects. .. 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 r)r4rrIrrrjrir5rFrQr _to_uri_saferrrrR) rr~rrZ native_iriZ ascii_irirrrrrrrTs+  rT&z ds.MultiDictzds.MultiDict[str, str])rr~ include_emptyr separatorclsr*cCsv|dkrddlm}|}t|trddlm} | }|| 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. .. versionchanged:: 2.0 The ``decode_keys`` and ``return_iterator`` parameters are deprecated and will be removed in Werkzeug 2.1. .. versionadded:: 0.8 r)make_chunk_iterN)r)Zwsgirrrr) rr~rrrrrr pair_iterdecoderrrrrurl_decode_stream`s!   r)rr~rrr*c csnxh|D]`}|sqt|}|d}||kr:||d\}}n|s@q|}|d}t|||t|||fVqWdS)NrrrJ)rrir) rr~rrpairrequalrrrrrrs  r)rr~rrrr*cCst|d}|t||||S)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. .. versionchanged:: 2.0 The ``encode_keys`` parameter is deprecated and will be removed in Werkzeug 2.1. .. versionchanged:: 0.5 Added the ``sort``, ``key``, and ``separator`` parameters. r )rrHr)rr~rrrrrr url_encodes r)rrr~rrrr*c CsVt|d}t||||}|dkr$|Sx,t|D] \}}|rD||||q.WdS)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. .. versionchanged:: 2.0 The ``encode_keys`` parameter is deprecated and will be removed in Werkzeug 2.1. .. versionadded:: 0.8 r N)rr enumeratewrite) rrr~rrrgenrrchunkrrrurl_encode_streams  r)baserrr*cst|trt|}t|tr$t|}t||ft||s@|S|sH|St||d\}}}}}t|||\}} } } } ||kr|S| rt|| | | | fS|} | dddkr| d} n@| s|d} | s|} n$|ddd| d} | ddkrd| d<fdd | D} xvd}t| d}x^||kr| |d kr| |ddd fkr| |d|d=P|d7}qBWPq0Wdd g}x| dd |kr| d=qWd| } t|| | | | fS) a 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. )rNrr].rJcsg|]}|dkr|qS)rr)rsegment)rrrrszurl_join..z..r^) r4rrIrrrFrirjrH)rrrbschemebnetlocbpathbquery bfragmentrrrrrsegmentsrnZunwanted_markerr)rrrGsT   $   0 rG)rJ)rJ)NT)rrNrrJ)rrNrrJ)rrNrJ)rr0rJ)rr0)r)rr)rrNF)rTr0rN)rTr0rNN)rFNr)NrFNr)T)Mrtcodecsrcretypingrv _internalrrrrr TYPE_CHECKINGrJrZdscompilerrrrr rrr NamedTuplerr%r{r}rDict FrozenSetr rr$Unionr#rMappingIterablerzboolryCallablerwIteratorrr>rFrrrrrQrrIrbrrrHrr5rregister_errorrVrrTAnyStrTyperDIOrrrrrGrrrrs       , & 2 *  ! "$?(('N\#<