.Ph LdZddlZddlZddlZddlmZedZejdZ dej DZ ejdZ idd d d d d ddddddddddddddddddddd d!d"d#d$d%d&d'id(d)d*d+d,dd-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdDddIdJdKdLdMddddN Z hdOZedPZedQZeezZeezZeez ZeezedRzZeez ZeezedSzZeez ZeeedTz zZeez ZGdUdVeZdWZdXZejdYZdd\Z d]Z!e!eZ"e!eZ#e!eZ$e!eZ%dd_Z&dd`Z'ddaZ(ddbZ)ddeZ*dfZ+ddgZ,dhZ-GdidjZ.GdkdlZ/ ddmlm0Z0nG#e1$r?ddl2Z2Gdndoe2j3Z4e2j5j6j7Z7e2j5j6j8Z8dpZ0YnwxYwdqZ9drZ:e:dsZ;d^efdtZ< ddul=m>Z>m?Z?m@Z@ddvlAmBZB dwdxlCmDZDeDdyzZEn#e1$r eFZEYnwxYweGd{\ZHZIZJZKZLZMGd|d}eNZO dwd~lPmOZOn #e1$rYnwxYweOZQGddeOZRdS)a:mod:`urlutils` is a module dedicated to one of software's most versatile, well-aged, and beloved data structures: the URL, also known as the `Uniform Resource Locator`_. Among other things, this module is a full reimplementation of URLs, without any reliance on the :mod:`urlparse` or :mod:`urllib` standard library modules. The centerpiece and top-level interface of urlutils is the :class:`URL` type. Also featured is the :func:`find_all_links` convenience function. Some low-level functions and constants are also below. The implementations in this module are based heavily on `RFC 3986`_ and `RFC 3987`_, and incorporates details from several other RFCs and `W3C documents`_. .. _Uniform Resource Locator: https://en.wikipedia.org/wiki/Uniform_Resource_Locator .. _RFC 3986: https://tools.ietf.org/html/rfc3986 .. _RFC 3987: https://tools.ietf.org/html/rfc3987 .. _W3C documents: https://www.w3.org/TR/uri-clarification/ N) normalizezB~-._0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzz~^((?P[^:/?#]+):)?((?P<_netloc_sep>//)(?P[^/?#]*))?(?P[^?#]*)(\?(?P[^#]*))?(#(?P.*))?c i|][}tjD]L}||zdtt ||zddM\S)asciicharmap)string hexdigitsencodechrint).0abs P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/boltons/urlutils.py rFs}FFFF4DFF/0a%((SQ^^$$++I66FFFFz([-]+)acapiafpi$dictiD dns5fileftpgiti$gopherFhttpPhttpsiimapippiwippsircircsi)ldapildapsi|mmsimsrpi' msrpsmtqpinfsonntpwnntpsi3popnprosperoiredisirsynciirtspi*rtspsiBrtspuisftpsmbisnmpijii ) sshsteamsvntelnetventrilovncwaiswswssxmpp> geosiptelurnblobdatanewssipsaboutmagnetmailtopkcs11bitcoinz:/?#[]@z !$&'()*+,;=z:@z/?z&=+ceZdZdZdS) URLParseErrorzException inheriting from :exc:`ValueError`, raised when failing to parse a URL. Mostly raised on invalid ports and IPv6 addresses. N)__name__ __module__ __qualname____doc__rrrZrZqs DrrZutf8cn t|S#t$rt|tcYSwxYw)N)encoding)strUnicodeDecodeErrorDEFAULT_ENCODING)objs r to_unicoderg{sG33xx 3333!12222223s  44z\b((?:([\w-]+):(/{1,3})|www[.])(?:(?:(?:[^\s&()<>]|&|")*(?:[^!"#$%'()*+,.:;<=>?@\[\]^`{|}~\s]))|(?:\((?:[^\s&()]|&|")*\)))+)Fr_c t|}d\}}}g j fd}t|D]}|d|d}}||kr|r ||||} |d} t| } | js,|rt|dz| z} n|||||r| j|vr||||n  | #t$r|r||||YwxYw|r||d} | r ||  S)alThis function uses heuristics to searches plain text for strings that look like URLs, returning a :class:`list` of :class:`URL` objects. It supports limiting the accepted schemes, and returning interleaved text as well. >>> find_all_links('Visit https://boltons.rtfd.org!') [URL(u'https://boltons.rtfd.org')] >>> find_all_links('Visit https://boltons.rtfd.org!', with_text=True) [u'Visit ', URL(u'https://boltons.rtfd.org'), u'!'] Args: text (str): The text to search. with_text (bool): Whether or not to interleave plaintext blocks with the returned URL objects. Having all tokens can be useful for transforming the text, e.g., replacing links with HTML equivalents. Defaults to ``False``. default_scheme (str): Many URLs are written without the scheme component. This function can match a reasonable subset of those, provided *default_scheme* is set to a string. Set to ``False`` to disable matching scheme-less URLs. Defaults to ``'https'``. schemes (list): A list of strings that a URL's scheme must match in order to be included in the results. Defaults to empty, which matches all schemes. .. note:: Currently this function does not support finding IPv6 addresses or URLs with netloc-less schemes, like mailto. )rNNc|r-tdtrdxx|z cc<dS|dSN) isinstancerc)t_addrets r _add_textz!find_all_links.._add_textsJ  :c"gs++  GGGqLGGGGG DGGGGGrrz://N) rgappend_FIND_ALL_URL_REfinditerstartendgroupURLschemerZ)text with_textdefault_schemeschemesprev_endrurvrpmatch cur_url_textcur_urltailrnros @@rfind_all_linksrsB d  D(HeS C :D "**400++[[^^UYYq\\s e    Dhun% & & & + ;;q>>L,''G> !!.5"8<"GHHGGId59o... 7>88 $uSy/****W  + + + + $uSy/***  + HII   IdOOO Js AD "*D  D/.D/ci}ttdtdD]1\}}t|}||vr |x||<||<#d|dx||<||<2|S)N%02X)zipranger ) safe_charsroivcs r_make_quote_maprs{ CE#JJc ++**1 FF ?? CFSVV)!kkk )CFSVV JrTc|rOtdt|d}dd|DSdd|DS)z8 Percent-encode a single segment of a URL path. NFCr`c(g|]}t|Sr_)_PATH_PART_QUOTE_MAPr rs r z#quote_path_part..sAAAA,Q/AAArc>g|]}|tvr t|n|Sr_) _PATH_DELIMSrr rms rrz#quote_path_part..s=$$$01L/@/@(++a$$$rrrgr joinrz full_quotebytestrs rquote_path_partrsCE:d#3#344;;FCCwwAAAAABBB 77$$"$$$ % %%rc|rOtdt|d}dd|DSdd|DS)z< Percent-encode a single query string key or value. rr`rc(g|]}t|Sr_)_QUERY_PART_QUOTE_MAPrs rrz$quote_query_part..sBBBQ-a0BBBrc>g|]}|tvr t|n|Sr_) _QUERY_DELIMSrrs rrz$quote_query_part..s=$$$12]0B0B)!,,$$$rrrs rquote_query_partrsDE:d#3#344;;FCCwwBB'BBBCCC 77$$"$$$ % %%rc|rOtdt|d}dd|DSdd|DS)zyQuote the fragment part of the URL. Fragments don't have subdelimiters, so the whole URL fragment can be passed. rr`rc(g|]}t|Sr_)_FRAGMENT_QUOTE_MAPrs rrz'quote_fragment_part..s@@@1+A.@@@rc>g|]}|tvr t|n|Sr_)_FRAGMENT_DELIMSrrs rrz'quote_fragment_part..s>$$$/03C.C.C'**$$$rrrs rquote_fragment_partrsBE:d#3#344;;FCCww@@@@@AAA 77$$"$$$ % %%rc|rOtdt|d}dd|DSdd|DS)zQuote special characters in either the username or password section of the URL. Note that userinfo in URLs is considered deprecated in many circles (especially browsers), and support for percent-encoded userinfo can be spotty. rr`rc(g|]}t|Sr_)_USERINFO_PART_QUOTE_MAPrs rrz'quote_userinfo_part..sEEE03EEErc>g|]}|tvr t|n|Sr_)_USERINFO_DELIMSrrs rrz'quote_userinfo_part..s?+++ !458H3H3H,Q//+++rrrs rquote_userinfo_partrs GE:d#3#344;;FCCwwEEWEEEFFF 77++%)+++ , ,,rutf-8replacecxd|vr |j|S|d}|d}t|}|dg}|j}tdt |dD]H}|t |||||||dzId|S) aPercent-decode a string, by replacing %xx escapes with their single-character equivalent. The optional *encoding* and *errors* parameters specify how to decode percent-encoded sequences into Unicode characters, as accepted by the :meth:`bytes.decode()` method. By default, percent-encoded sequences are decoded with UTF-8, and invalid sequences are replaced by a placeholder character. >>> unquote(u'abc%20def') u'abc def' rNrrrrqr)split _ASCII_RErrrlenunquote_to_bytesdecoder)rrberrorsbitsresrrrs runquoters &   ~ ??6 " "D 7)C ZF 1c$ii # #Q((//&AABBBtAE{ 773<<rc|s |jdSt|tr|jd}|jd}t |dkr|S|dg}|j}|ddD]Z} |t |dd||dd5#t$r|d||YWwxYwd|S)z,unquote_to_bytes('abc%20def') -> b'abc def'.rr%rqrNr) rrlrcr rrr _HEX_CHAR_MAPKeyErrorr)rrrrritems rrr0s  s&#(w'' 6<  D 4yyA~~ 7)C ZFQRR  F=bqb* + + + F48        F4LLL F4LLLLL  88C==s31B%% CCc:|}|1 t|}n #t$rtd|wxYw|dur |t|<nD|dur/|td|zt|n|tddS)aRegisters new scheme information, resulting in correct port and slash behavior from the URL object. There are dozens of standard schemes preregistered, so this function is mostly meant for proprietary internal customizations or stopgaps on missing standards information. If a scheme seems to be missing, please `file an issue`_! Args: text (str): Text representing the scheme. (the 'http' in 'http://hatnote.com') uses_netloc (bool): Does the scheme support specifying a network host? For instance, "http" does, "mailto" does not. default_port (int): The default port, if any, for netloc-using schemes. .. _file an issue: https://github.com/mahmoud/boltons/issues Nz+default_port expected integer or None, not TFz>unexpected default port while specifying non-netloc scheme: %rz)uses_netloc expected True, False, or None)lowerr ValueErrorSCHEME_PORT_MAPNO_NETLOC_SCHEMESadd)rz uses_netloc default_ports rregister_schemerKs$ ::<t|d|_||_dS)Nr^)getattrr^func)selfrs r__init__zcachedproperty.__init__stY//  rNc`||S||x}|j|jj<|SN)r__dict__r[)rrfobjtypevalues r__get__zcachedproperty.__get__s1 ;K3799S>>A TY/0 rc6|jj}d|d|jdS)N) __class__r[rrcns r__repr__zcachedproperty.__repr__s' ^ $)2))TY))))rr)r[r\r]r^rrrr_rrrrsP *****rrceZdZdZdZddZe ddZedZ e Z e d Z e j d Z e d Ze d ZddZdZddZddZdZdZdZdZdZdS)rxa}The URL is one of the most ubiquitous data structures in the virtual and physical landscape. From blogs to billboards, URLs are so common, that it's easy to overlook their complexity and power. There are 8 parts of a URL, each with its own semantics and special characters: * :attr:`~URL.scheme` * :attr:`~URL.username` * :attr:`~URL.password` * :attr:`~URL.host` * :attr:`~URL.port` * :attr:`~URL.path` * :attr:`~URL.query_params` (query string parameters) * :attr:`~URL.fragment` Each is exposed as an attribute on the URL object. RFC 3986 offers this brief structural summary of the main URL components:: foo://user:pass@example.com:8042/over/there?name=ferret#nose \_/ \_______/ \_________/ \__/\_________/ \_________/ \__/ | | | | | | | scheme userinfo host port path query fragment And here's how that example can be manipulated with the URL type: >>> url = URL('foo://example.com:8042/over/there?name=ferret#nose') >>> print(url.host) example.com >>> print(url.get_authority()) example.com:8042 >>> print(url.qp['name']) # qp is a synonym for query_params ferret URL's approach to encoding is that inputs are decoded as much as possible, and data remains in this decoded state until re-encoded using the :meth:`~URL.to_text()` method. In this way, it's similar to Python's current approach of encouraging immediate decoding of bytes to text. Note that URL instances are mutable objects. If an immutable representation of the URL is desired, the string from :meth:`~URL.to_text()` may be used. For an immutable, but almost-as-featureful, URL object, check out the `hyperlink package`_. .. _hyperlink package: https://github.com/mahmoud/hyperlink ) ryrusernamepasswordfamilyhostportpath query_paramsfragmentrcFt}|rt|tr|}n^t|trI |t }n-#t$r }tdt d|dd}~wwxYwt|}d}|dp||_ |dp||_ d|dp|vrt|dn |dp||_ d|d p|vrt|d n |d p||_|d |_|d s||_n^ |d d |_|jd |_n#t$$r|d |_YnwxYw|d|_t)d|dp|dD|_|dp||_d|dp|vrt|dn |dp||_dS)Nzexpected text or zI-encoded bytes. try decoding the url bytes and passing the result. (got: )rry _netloc_seprrrrrridnarc8g|]}d|vrt|n|Srrr ps rrz URL.__init__..s<!C!C!C1saxxQ!C!C!Crr/queryr)DEFAULT_PARSED_URLrlrxto_textbytesrrerdrZ parse_urlryrrrrrrr UnicodeEncodeErrorrtuplerr_queryr)rurludude_es rrz URL.__init__s   #s## CkkmmC'' CC**%566CC)CCC'-,<+;+;SSS)BCCCC 3B l(b m,2BzN$8b99!J000?A*~?SQS  BzN$8b99!J000?A*~?SQS l &z 5DII 5vJ--g66 !I,,V44 & ' ' 'vJ  ' vJ !C!C%'Z%52$<$>> url = URL('http://boltons.readthedocs.io/?utm_source=doctest&python=great') >>> url.qp.keys() [u'utm_source', u'python'] )QueryParamDict from_textrrs rrzURL.query_params-s'' 444rcJdd|jDS)zThe URL's path, in text form.rc0g|]}t|dS)Frrrs rrzURL.path..>s5444)u===444r)rrr s rrzURL.path;s8xx44#'?44455 5rctdt|dD|_dS)Nc8g|]}d|vrt|n|Srrrs rrzURL.path..Cs@!L!L!L%&03axxQ!L!L!Lrr)rrgrr)r path_texts rrzURL.pathAsQ!L!L*4Y*?*?*E*Ec*J*J!L!L!LMMrc|j}|jtvrdS|jtvrdS|jddtvrdS|S)a1Whether or not a URL uses :code:`:` or :code:`://` to separate the scheme from the rest of the URL depends on the scheme's own standard definition. There is no way to infer this behavior from other parts of the URL. A scheme either supports network locations or it does not. The URL type's approach to this is to check for explicitly registered schemes, with common schemes like HTTP preregistered. This is the same approach taken by :mod:`urlparse`. URL adds two additional heuristics if the scheme as a whole is not registered. First, it attempts to check the subpart of the scheme after the last ``+`` character. This adds intuitive behavior for schemes like ``git+ssh``. Second, if a URL with an unrecognized scheme is loaded, it will maintain the separator it sees. >>> print(URL('fakescheme://test.com').to_text()) fakescheme://test.com >>> print(URL('mockscheme:hello:world').to_text()) mockscheme:hello:world TF+rk)rryrrr)rdefaults rrzURL.uses_netlocGs[4" ;/ ) )4 ;+ + +5 ;  S ! !" % 8 84rc t|jS#t$r;t|jddcYSwxYw)acReturn the default port for the currently-set scheme. Returns ``None`` if the scheme is unrecognized. See :func:`register_scheme` above. If :attr:`~URL.port` matches this value, no port is emitted in the output of :meth:`~URL.to_text()`. Applies the same '+' heuristic detailed in :meth:`URL.uses_netloc`. rrk)rryrgetrr s rrzURL.default_portjsc C"4;/ / C C C"&&t{'8'8'='=b'ABB B B B CsAAATct|j|_|r<|j|_|j|_dS)aRResolve any "." and ".." references in the path, as well as normalize scheme and host casing. To turn off case normalization, pass ``with_case=False``. More information can be found in `Section 6.2.2 of RFC 3986`_. .. _Section 6.2.2 of RFC 3986: https://tools.ietf.org/html/rfc3986#section-6.2.2 N)rrryrr)r with_cases rrz URL.normalizeysJ-T_==  *+++--DK ))DIrc d}t|tst||}}|jr|jr|t|n|S|j}|jra|jdrt|j}nOt|jddt|jz}nt|j}|s|j}| |jp|j|jp|j|j p|j |||j |j p|j |j p|j }||S)azFactory method that returns a _new_ :class:`URL` based on a given destination, *dest*. Useful for navigating those relative links with ease. The newly created :class:`URL` is normalized before being returned. >>> url = URL('http://boltons.readthedocs.io') >>> url.navigate('en/latest/') URL(u'http://boltons.readthedocs.io/en/latest/') Args: dest (str): A string or URL object representing the destination More information can be found in `Section 5 of RFC 3986`_. .. _Section 5 of RFC 3986: https://tools.ietf.org/html/rfc3986#section-5 Nrrk)ryrrrrrrr)rlrxryrrr startswithrrr rrrrr)rdest orig_destrnew_path_partsros rnavigatez URL.navigatesP$ $$$ .!$ii)D ; <49 <!* 13t999t ;( 9 1y##C(( 7!%do!6!6!%docrc&:!;!;!%do!6!6"7"$/22N 1#0 ooT[%?DK#'9#9 #'9#9 )7+7'+}'+}'E '+}'E GG  rFcg}|j}|jrY|rW|t|j|jr(|d|t|j|d|jr|jt jkr'|d||j|dnI|r7||jd dn||j|j r8|j |j kr(|d|t|j d |S)aUsed by URL schemes that have a network location, :meth:`~URL.get_authority` combines :attr:`username`, :attr:`password`, :attr:`host`, and :attr:`port` into one string, the *authority*, that is used for connecting to a network-accessible resource. Used internally by :meth:`~URL.to_text()` and can be useful for labeling connections. >>> url = URL('ftp://user@ftp.debian.org:2121/debian/README') >>> print(url.get_authority()) ftp.debian.org:2121 >>> print(url.get_authority(with_userinfo=True)) user@ftp.debian.org:2121 Args: full_quote (bool): Whether or not to apply IDNA encoding. Defaults to ``False``. with_userinfo (bool): Whether or not to include username and password, technically part of the authority. Defaults to ``False``. :@[]rrr)rrrrrrrsocketAF_INET6r rrrrcr)rr with_userinfopartsrns r get_authorityzURL.get_authoritysU0| = ]  D$T]33 4 4 4} 9S (77888 DIII 9 %{fo--S TYS  TY%%f--44W==>>>>TYy %TY$*;;;S S^^$$$wwu~~rc|j}dfd|jD}|d}|j}t |j}g}|j}|r|||d|r|d||n"|r |dd dkr|j r |d|r(|r|r|dd dkr |d|||r|d |||r|d ||d |S)a~Render a string representing the current state of the URL object. >>> url = URL('http://listen.hatnote.com') >>> url.fragment = 'en' >>> print(url.to_text()) http://listen.hatnote.com#en By setting the *full_quote* flag, the URL can either be fully quoted or minimally quoted. The most common characteristic of an encoded-URL is the presence of percent-encoded text (e.g., %60). Unquoted URLs are more readable and suitable for display, whereas fully-quoted URLs are more conservative and generally necessary for sending over the network. rc2g|]}t|S)rr)r rrs rrzURL.to_text..s6444)zBBB444rT)rr)rr#z//Nrrq?#r) ryrrr+rrrrrrr) rrryr authority query_stringrr*rns ` rrz URL.to_texts xx4444#'?44455&&*59';; (00J0GG &t}LLL|   DLLL DIII   DJJJ DOOOO bqbT))d.>) DJJJ   ) RaRCS  DJJJ   DIII D      DIII DNNNwwu~~rcN|jj}|d|dS)N(r)rr[rrs rrz URL.__repr__s+ ^ $**t||~~****rc*|Srrr s r__str__z URL.__str__||~~rc*|Srr5r s r __unicode__zURL.__unicode__ r7rcf|jD](}t||t||dksdS)dS)NFT) _cmp_attrsr)rotherattrs r__eq__z URL.__eq__#sFO  D4&&'%t*D*DDDuuEtrc||k Srr_rr<s r__ne__z URL.__ne__)s5=  rr)NNr_r_rNNNT)FFF)r[r\r]r^r;r classmethodr rrqppropertyrsetterrrrr!r+rrr6r9r>rAr_rrrxrxs11hPJ,,,,\LNCG"""["H 5 5^ 5 B 55X5  [[   X D C CX C ///b----^....`+++ !!!!!rrx) inet_ptoncneZdZdejfdejfdejdzfdejdzfdejfgZdS) _sockaddr sa_family__pad1 ipv4_addr ipv6_addrr__pad2N) r[r\r]ctypesc_shortc_ushortc_bytec_ulong_fields_r_rrrJrJ3sQ &.1v/ &-!"34 &-""45v~. 0rrJc t}|d}||_tjtj|}t ||dtj|tj|dkr ttj |tj krtj |j dS|tjkrtj |jdStd)NrrrNrzunknown address family)rJr rKrQc_intsizeofWSAStringToAddressAbyrefOSError FormatErrorr'AF_INET string_atrMr(rO)address_family ip_stringaddr addr_sizes rrHrH=s{{$$W-- 'Lt!4!455 y.$ T@R@RTZT`ajTkTk l lpq q q&,..// / V^ + +#DNA66 6 V_ , ,#DNB77 7.///rc|sdSd|vrd|dkrtd|dkrh|dd} ttj|tj}||fS#t$r}t d|d |d d }~wt $rYnwxYw ttj|tj}n#tt f$rd }YnwxYw||fS) a Low-level function used to parse the host portion of a URL. Returns a tuple of (family, host) where *family* is a :mod:`socket` module constant or ``None``, and host is a string. >>> parse_host('googlewebsite.com') == (None, 'googlewebsite.com') True >>> parse_host('[::1]') == (socket.AF_INET6, '::1') True >>> parse_host('192.168.1.1') == (socket.AF_INET, '192.168.1.1') True Odd doctest formatting above due to py3's switch from int to enums for :mod:`socket` constants. )Nrr#r%rr&rkrqzinvalid IPv6 host: z (rN)rHr'r(r\rZrr^)rrses r parse_hostrfMs $ x d{{sd1g~~#b//AbDz fot , , , _F4<   I I I Gd G G G G GHH H!    D   &.$''' ' ( 4<s/A B A66 BB B11CCct|}t|} |}n #t$rt d|zwxYw|d}dd|}}}|r4|d\}}}|r|d\}} }d\} } |r|d\} }} |r| rL| ddkr@d | vr<| d \} } } | dz| zd z} | r| ddkr | d d} t| } n&#t$r| rt d | zd} YnwxYwt| \}} ||d <||d <||d<| |d<| |d<|S)a+ Used to parse the text for a single URL into a dictionary, used internally by the :class:`URL` type. Note that "URL" has a very narrow, standards-based definition. While :func:`parse_url` may raise :class:`URLParseError` under a very limited number of conditions, such as non-integer port, a surprising number of strings are technically valid URLs. For instance, the text ``"url"`` is a valid URL, because it is a relative path. In short, do not expect this function to validate form inputs or other more colloquial usages of URLs. >>> res = parse_url('http://127.0.0.1:3000/?a=1') >>> sorted(res.keys()) # res is a basic dictionary ['_netloc_sep', 'authority', 'family', 'fragment', 'host', 'password', 'path', 'port', 'query', 'scheme', 'username'] zcould not parse url: %rr0Nr$r#NNrr%r&rqz!expected integer for port, not %rrrrrr) rc_URL_REr groupdictAttributeErrorrZ rpartition partitionr rrf)url_textumgsau_textuserpwhostinfouserinfosep_rrport_str host_rightrs rrrus&8}}H x BB \\^^ BBB5@AAABoGtWh"D2")"4"4S"9"9#x  2",,S11KD!RJD$&0055c8   ,Q33(??*2*<*.s/ @ @ @B"((3-- @ @BR @ @ @ @r&=Nr )rrmrrrr) qskeep_blank_valuesrbpairsropairkeyrwrs r parse_qslrs A @"((3-- @ @ @E C ! !  s++ Q   ckk#s++,,  5EMM#s3344E C<    Jr)KeysView ValuesView ItemsView) zip_longestrq) make_sentinel_MISSING)var_nameceZdZdZfdZfdZdZdZdZdZ fdZ fd Z d0fd Z e ffd Zfd Ze ffd ZdZed0dZdZdZfdZfdZfdZdZdZdZe fdZe ffd Ze e ffd ZdZdZ d1dZ!d1d Z"d1d!Z#d1d"Z$d2d#Z%d2fd$ Z&d%Z'fd&Z(d1d'Z)d1d(Z*d1d)Z+d*Z,fd+Z-d,Z.d-Z/d.Z0d/Z1xZ2S)3OrderedMultiDicta A MultiDict is a dictionary that can have multiple values per key and the OrderedMultiDict (OMD) is a MultiDict that retains original insertion order. Common use cases include: * handling query strings parsed from URLs * inverting a dictionary to create a reverse index (values to keys) * stacking data from multiple dictionaries in a non-destructive way The OrderedMultiDict constructor is identical to the built-in :class:`dict`, and overall the API constitutes an intuitive superset of the built-in type: >>> omd = OrderedMultiDict() >>> omd['a'] = 1 >>> omd['b'] = 2 >>> omd.add('a', 3) >>> omd.get('a') 3 >>> omd.getlist('a') [1, 3] Some non-:class:`dict`-like behaviors also make an appearance, such as support for :func:`reversed`: >>> list(reversed(omd)) ['b', 'a'] Note that unlike some other MultiDicts, this OMD gives precedence to the most recent value added. ``omd['a']`` refers to ``3``, not ``1``. >>> omd OrderedMultiDict([('a', 1), ('b', 2), ('a', 3)]) >>> omd.poplast('a') 3 >>> omd OrderedMultiDict([('a', 1), ('b', 2)]) >>> omd.pop('a') 1 >>> omd OrderedMultiDict([('b', 2)]) If you want a safe-to-modify or flat dictionary, use :meth:`OrderedMultiDict.todict()`. >>> from pprint import pprint as pp # preserve printed ordering >>> omd = OrderedMultiDict([('a', 1), ('b', 2), ('a', 3)]) >>> pp(omd.todict()) {'a': 3, 'b': 2} >>> pp(omd.todict(multi=True)) {'a': [1, 3], 'b': [2]} With ``multi=False``, items appear with the keys in to original insertion order, alongside the most-recently inserted value for that key. >>> OrderedMultiDict([('a', 1), ('b', 2), ('a', 3)]).items(multi=False) [('a', 3), ('b', 2)] .. warning:: ``dict(omd)`` changed behavior `in Python 3.7 `_ due to changes made to support the transition from :class:`collections.OrderedDict` to the built-in dictionary being ordered. Before 3.7, the result would be a new dictionary, with values that were lists, similar to ``omd.todict(multi=True)`` (but only shallow-copy; the lists were direct references to OMD internal structures). From 3.7 onward, the values became singular, like ``omd.todict(multi=False)``. For reliable cross-version behavior, just use :meth:`~OrderedMultiDict.todict()`. crt|}||Sr)super__new__ _clear_ll)rrkwrors rrzOrderedMultiDict.__new__*s*ggooc""  rc0t|dkr+t|jjdt|t |r||d|r||dSdS)Nrqz" expected at most 1 argument, got r)r TypeErrorrr[rr update_extendr)rargskwargsrs rrzOrderedMultiDict.__init__/s t99q==#~666D CDD D   (   tAw ' ' '  KK       rcHt|dS)NTmultir iteritemsr s r __getstate__zOrderedMultiDict.__getstate__:sDNNN..///rcX|||dSr)clearr)rstates r __setstate__zOrderedMultiDict.__setstate__=s)  5!!!!!rc |j}n #t$rix}|_g|_YnwxYw||j|jdg|jdd<dSr)_maprkrootr)rrs rrzOrderedMultiDict._clear_llAso 9DD   ! !D49DIII   49d3 !!! s  ''c|j}|j|g}|t}||||g}|x|t<|t<||dSr)rr setdefaultPREVNEXTrr)rkrrcellslastcells r_insertzOrderedMultiDict._insertJsay $$Q++DzdAq!"&&T T$Z Trct|g}|||||dS)zaAdd a single value *v* under a key *k*. Existing values under *k* are preserved. N)rrrrr)rrrvaluesrs rrzOrderedMultiDict.addRsJ##Ar** Q arc|sdS|j}t|g}|D]}|||||dS)aAdd an iterable of values underneath a specific key, preserving any values already under that key. >>> omd = OrderedMultiDict([('a', -1)]) >>> omd.addlist('a', range(3)) >>> omd OrderedMultiDict([('a', -1), ('a', 0), ('a', 1), ('a', 2)]) Called ``addlist`` for consistency with :meth:`getlist`, but tuples and other sequences and iterables work. N)rrrextend)rrr self_insertrsubvrs raddlistzOrderedMultiDict.addlistZsn  Fl ##Ar** ! !D K4  arNcVt||gdS)aReturn the value for key *k* if present in the dictionary, else *default*. If *default* is not given, ``None`` is returned. This method never raises a :exc:`KeyError`. To get all values under a key, use :meth:`OrderedMultiDict.getlist`. rk)rrrrrrs rrzOrderedMultiDict.getns$ww{{1wi((,,rc t|ddS#t$r|turgcYS|cYSwxYw)zGet all values for key *k* as a list, if *k* is in the dictionary, else *default*. The list returned is a copy and can be safely mutated. If *default* is not given, an empty :class:`list` is returned. N)r __getitem__rrrs rgetlistzOrderedMultiDict.getlistwsa  77&&q))!!!, ,   ("" NNN s(,AAAcpt|dS)zEmpty the dictionary.N)rrr)rrs rrzOrderedMultiDict.clears*   rcvt|s|turdn|||<||S)zIf key *k* is in the dictionary, return its value. If not, insert *k* with a value of *default* and return *default*. *default* defaults to ``None``. See :meth:`dict.setdefault` for more information. N)r __contains__rrs rrzOrderedMultiDict.setdefaults? ww##A&& ?%11ddwDGAwrcT||dS)z(Return a shallow copy of the dictionary.Trrrr s rcopyzOrderedMultiDict.copys"~~dnn4n88999rc2|fd|DS)zCreate a dictionary from a list of keys, with all the values set to *default*, or ``None`` if *default* is not set. cg|]}|fSr_r_)r rrs rrz-OrderedMultiDict.fromkeys..s///QQL///rr_)rkeysrs `rfromkeyszOrderedMultiDict.fromkeyss* s////$///000rc ||urdS|j}t|tr5|D] }||vr||= |dD]\}}|||nt t |ddr#|D] }||||<n?t}|j}|D]'\}}||vr||vr||=|||||(|D] }||||<dS)zAdd items from a dictionary or iterable (and/or keyword arguments), overwriting values under an existing key. See :meth:`dict.update` for more details. NTrr)rrlrrcallablerrset)rEFself_addrrseenseen_adds rrzOrderedMultiDict.updatesH 99 F8 a) * *   99Q $ //  1A  ga.. / / VVXX  A$Q 55DxH  1D==Q$YYQHQKKKA  AdDGGrc H|ur"t}n_ttrd}n3t dr!fdD}n}|j}|D]\}}|||dS)zAdd items from a dictionary, iterable, and/or keyword arguments without overwriting existing items present in the dictionary. Like :meth:`update`, but adds to existing keys instead of overwriting them. Trrc3,K|]}||fVdSrr_)r rrs r z1OrderedMultiDict.update_extend..s+44aAaD 444444rN)iteritemsrlrrhasattrrr)rrriteratorrrrs ` rrzOrderedMultiDict.update_extends 99AGGIIHH + , , {{{..HH Q   444416688444HHH8  DAq HQNNNN  rct|r|||||t||gdSr)rr _remove_allr __setitem__)rrrrs rrzOrderedMultiDict.__setitem__sg 77   " "   Q    Q As#####rcRt|dSrj)rrrrrs rrzOrderedMultiDict.__getitem__s ww""1%%b))rctt|||dSr)r __delitem__rrs rrzOrderedMultiDict.__delitem__s5 A rcL||urdS t|t|krdSn#t$rYdSwxYwt|tr|d}|d}t ||d}|D]\\}}\}}||ks||krdSt |tturt |ttusdSdSt|dr,|D]'} ||||k#t$rYdSwxYwdSdS)NTFrrh) fillvaluer) rrrlrrrnextrrr) rr<selfiotheri zipped_itemsselfkselfvotherkothervs rr>zOrderedMultiDict.__eq__s} 5==4 5zzSYY&&u'   55  e- . . NNN..E__4_00F&uf MMML4@ ! !0 0F??evoo 55'6x((H44FH--99u4 UF # #  ! !!%LDK///!!! 555!4us + 99=D DDc||k Srr_r@s rrAzOrderedMultiDict.__ne__sEM""rc0|||Sr)rr@s r__ior__zOrderedMultiDict.__ior__s E rc ||dS#t$r|turt|YnwxYw|S)zRemove all values under key *k*, returning the most-recently inserted value. Raises :exc:`KeyError` if the key is not present and no *default* is provided. rk)popallrr)rrrs rr3zOrderedMultiDict.pops]  ";;q>>"% % " " "(""qkk!#" "s"AAct}||r|||tur||S|||S)zRemove all values under key *k*, returning them in the form of a list. Raises :exc:`KeyError` if the key is not present and no *default* is provided. )rrrrr3)rrr super_selfrs rrzOrderedMultiDict.popall si WW  " "1 % %   Q    h  >>!$$ $~~a)))rc|turJ|r|jtt}n*|turt dt |z|S ||n*#t$r|turt ||cYSwxYwt|}| }|s!t ||S)aERemove and return the most-recently inserted value under the key *k*, or the most-recently inserted key if *k* is not provided. If no values remain under *k*, it will be removed from the OMD. Raises :exc:`KeyError` if *k* is not present in the dictionary, or the dictionary is empty. zempty %r) rrrKEYrtype_removerrr3r)rrrrrrs rpoplastzOrderedMultiDict.poplasts == IdOC(h&&":T #:;;;  LLOOOO   (""qkk!NNN $$Q'' JJLL # GG   " " "sA,,$BBc|j|}|}|t|tc|tt<|tt<|s |j|=dSdSrrr3rrrrrrs rrzOrderedMultiDict._remove2s_1zz||-1$Zd*T 4$t*T*  !   rc|j|}|rW|}|t|tc|tt<|tt<|W|j|=dSrrrs rrzOrderedMultiDict._remove_all9sc1 H::< NNN//  DAqGGGG  rc@|rfdDSfdDS)apGets a basic :class:`dict` of the items in this dictionary. Keys are the same as the OMD, values are the most recently inserted values for each key. Setting the *multi* arg to ``True`` is yields the same result as calling :class:`dict` on the OMD, except that all the value lists are copies that can be safely mutated. c<i|]}||Sr_)rr rrs rrz+OrderedMultiDict.todict..xs%5551At||A555rc"i|] }|| Sr_r_rs rrz+OrderedMultiDict.todict..ys)))q47)))rr_rrs` rtodictzOrderedMultiDict.todictnsA  65555555 5))))D))))rcn|j}|t|d||S)aSimilar to the built-in :func:`sorted`, except this method returns a new :class:`OrderedMultiDict` sorted by the provided key function, optionally reversed. Args: key (callable): A callable to determine the sort key of each element. The callable should expect an **item** (key-value pair tuple). reverse (bool): Set to ``True`` to reverse the ordering. >>> omd = OrderedMultiDict(zip(range(3), range(3))) >>> omd.sorted(reverse=True) OrderedMultiDict([(2, 2), (1, 1), (0, 0)]) Note that the key function receives an **item** (key-value tuple), so the recommended signature looks like: >>> omd = OrderedMultiDict(zip('hello', 'world')) >>> omd.sorted(key=lambda i: i[1]) # i[0] is the key, i[1] is the val OrderedMultiDict([('o', 'd'), ('l', 'l'), ('e', 'o'), ('l', 'r'), ('h', 'w')]) Trrreverse)rsortedr)rrr rs rr zOrderedMultiDict.sorted{s8,ns6$..t.44#wOOOPPPrc t}n0#t$r#t}YnwxYwfd|D}|}|dD]0}||||1|S)aHReturns a copy of the :class:`OrderedMultiDict` with the same keys in the same order as the original OMD, but the values within each keyspace have been sorted according to *key* and *reverse*. Args: key (callable): A single-argument callable to determine the sort key of each element. The callable should expect an **item** (key-value pair tuple). reverse (bool): Set to ``True`` to reverse the ordering. >>> omd = OrderedMultiDict() >>> omd.addlist('even', [6, 2]) >>> omd.addlist('odd', [1, 5]) >>> omd.add('even', 4) >>> omd.add('odd', 3) >>> somd = omd.sortedvalues() >>> somd.getlist('even') [2, 4, 6] >>> somd.keys(multi=True) == omd.keys(multi=True) True >>> omd == somd False >>> somd OrderedMultiDict([('even', 2), ('even', 4), ('odd', 1), ('odd', 3), ('even', 6), ('odd', 5)]) As demonstrated above, contents and key order are retained. Only value order changes. c>i|]\}}|t| S)r)r )r rrrr s rrz1OrderedMultiDict.sortedvalues..sF@@@#'1aVA3WFFF@@@rTr)rrrkrrrrr3)rrr superself_iteritemssorted_val_maprorrs `` r sortedvalueszOrderedMultiDict.sortedvaluess< 2"'''"3"3"5"5   2 2 2"'''--//    2@@@@@+>@@@nnT** 0 0A GGA~a(,,.. / / / / s &*AAch|d|dDS)aReturns a new :class:`OrderedMultiDict` with values and keys swapped, like creating dictionary transposition or reverse index. Insertion order is retained and all keys and values are represented in the output. >>> omd = OMD([(0, 2), (1, 2)]) >>> omd.inverted().getlist(2) [0, 1] Inverting twice yields a copy of the original: >>> omd.inverted().inverted() OrderedMultiDict([(0, 2), (1, 2)]) c3$K|] \}}||fV dSrr_r rrs rrz,OrderedMultiDict.inverted..s*LLAq!fLLLLLLrTrrr s rinvertedzOrderedMultiDict.inverteds3~~LLd1K1KLLLLLLrcntj|fd|DS)zReturns a mapping from key to number of values inserted under that key. Like :py:class:`collections.Counter`, but returns a new :class:`OrderedMultiDict`. c3LK|]}|t|fVdSr)r)r r super_getitems rrz*OrderedMultiDict.counts..s:GGQq#mmA&6&6"7"78GGGGGGr)rrr)rrrs @rcountszOrderedMultiDict.countss9+ ~~GGGG$GGGGGGrcHt||S)ztReturns a list containing the output of :meth:`iterkeys`. See that method's docs for more details. r)rrrs rrzOrderedMultiDict.keyss DMMM..///rcHt||S)zvReturns a list containing the output of :meth:`itervalues`. See that method's docs for more details. r)rrrs rrzOrderedMultiDict.valuess DOO%O00111rcHt||S)zuReturns a list containing the output of :meth:`iteritems`. See that method's docs for more details. rrrs rrzOrderedMultiDict.itemss DNNN//000rc*|Sr)rr s r__iter__zOrderedMultiDict.__iter__s}}rc#,K|j}|t}i}|j}tj}||ur\|t }||}||dt |kr|V||xxdz cc<|t}||uZdSdS)Nrq)rrrrrrr) rrrlengths lengths_sd get_valuesrvalsrs r __reversed__zOrderedMultiDict.__reversed__syDz' WW( $S A:a==Dz!Q3t99,, AJJJ!OJJJ:D $rc|jj}dd|dD}|d|dS)Nz, c6g|]\}}t||fSr_)reprrs rrz-OrderedMultiDict.__repr__..s&MMM$!Qq!fMMMrTrz([z]))rr[rr)rrkvss rrzOrderedMultiDict.__repr__sQ ^ $iiMM$..t.2L2LMMMNNrc t|S)zBOMD.viewkeys() -> a set-like object providing a view on OMD's keys)rr s rviewkeyszOrderedMultiDict.viewkeyss~~rc t|S)z>OMD.viewvalues() -> an object providing a view on OMD's values)rr s r viewvalueszOrderedMultiDict.viewvaluess$rc t|S)zDOMD.viewitems() -> a set-like object providing a view on OMD's items)rr s r viewitemszOrderedMultiDict.viewitems srrrC)NF)3r[r\r]r^rrrrrrrrrrrrrrrDrrrrrrr>rArr3rrrrrrrrr rrrrrrrr"rr(r*r, __classcell__)rs@rrrsHHR      000"""444(------"*       %-:::111[1 <&$$$$$ *****:###&    !) * * * * * *!(4 % % % %"""", * * * *QQQQ2((((((TMMM"HHHHH0000 2222 1111            rr)rc0eZdZdZedZddZdS)r aoA subclass of :class:`~dictutils.OrderedMultiDict` specialized for representing query string values. Everything is fully unquoted on load and all parsed keys and values are strings by default. As the name suggests, multiple values are supported and insertion order is preserved. >>> qp = QueryParamDict.from_text(u'key=val1&key=val2&utm_source=rtd') >>> qp.getlist('key') [u'val1', u'val2'] >>> qp['key'] u'val2' >>> qp.add('key', 'val3') >>> qp.to_text() 'key=val1&key=val2&utm_source=rtd&key=val3' See :class:`~dictutils.OrderedMultiDict` for more API features. c:t|d}||S)zP Parse *query_string* and return a new :class:`QueryParamDict`. T)r)r)rr1rs rr zQueryParamDict.from_text,s$ ,$???s5zzrFcdg}|dD]\}}tt||}|||;tt||}|d||fd|S)z Render and return a query string. Args: full_quote (bool): Whether or not to percent-quote special characters or leave them decoded for readability. TrrNrr)rrrgrrr)rrret_listrrrvals rrzQueryParamDict.to_text4sNNN.. 6 6DAq":a==ZHHHCy$$$$&z!}}LLL#s 4 45555xx!!!rNrC)r[r\r]r^rDr rr_rrr r sM&[""""""rr )Fr r_rB)rrrh)Sr^rer'r unicodedatar frozenset_UNRESERVED_CHARScompilerir rrrr _GEN_DELIMS _SUB_DELIMS _ALL_DELIMS_USERINFO_SAFErr _PATH_SAFEr_FRAGMENT_SAFEr _QUERY_SAFErrrZrergrsrrrrrrrrrrrrrrrrxrH ImportErrorrQ StructurerJwindllws2_32rZWSAAddressToStringArfrrrcollections.abcrrr itertoolsr typeutilsrrobjectrrrrrSPREVSNEXTrr dictutilsOMDr r_rrrLs;>, !!!!!!I;<< "*- . .FF *FFF  BJ' ( (  D63 Ds DFD D% D4 D!& D,14 D9A2 D2 D& D-3S D:? D3 D!&s D-3D D;A# DC D D"' D/5d D=DT D 4 D "' D .4S D ;B3 D # D *4 D 29$ D AH D3 D!( D/6t D>DR D# D &s D D46"$tbd D D D/// i "" i && K' "[0/  ,ss4yy 8 Z' "Z/##d));/.33u::"== k)      J   3332:tuuIIIIX   +?>::&z22' 44%on55%%%%%%%%%%%% , , , ,66$ $ $ $ N.********2H!H!H!H!H!H!H!H!V 0       000MMM00000F$000!-.B -.B 0 0 0 0 00<%%%P===@Yr]]%)3C, <;;;;;;;;;!!!!!!((((((}j111HHvxxHHH(-uQxx$dCukkkkktkkk^ +++++++   D ,",",",","%,",",",","s7G AH  H 9I IIJ JJ