=*h\ dZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl Z ddlZddlmZddlZddlZddlmZmZmZmZddlmZmZmZddlmZmZe ddlZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*ejVrdd lm,Z,dd l-m.Z.ddl/Z/e d d e0de0fdZ1GddejdjfZ4Gdde5Z6Gdde7Z8Gdde7Z9Gdde5Z:Gdde5Z;Gdde5Zd$e0de'e e'e?e'e?ffd%Z@d&e'e?d'e'e?d(e?de0fd)ZAd*e0de'e?fd+ZB dUd,e0d-eCd.e%e0e"eCfd/e%e0e"e>fd0e'e4ddf d1ZDd2eCd3eCd.e%e0e"eCfd/e%e0e"e>fddf d4ZEd5e&e?eFeGejej fde0fd6ZIejd7gd8ZKejd9ZMd:e0deKfd;ZNejdZPd:e0deOfd?ZQd@e0de)e0ddffdAZRd:e0de e0e%e0e0fffdBZSdCe0dDe%e0e0fde0fdEZTdFe&e0eCfdGe&e0eCfdeCfdHZUdIZVejdJZWdKe0de e0e'e?ffdLZXdMe%e0e"e*fde!e e0e*ffdNZYejdOjZ[dPejde0fdQZ]d@e0de0fdRZ^dSe0de%e0e0ffdTZ_y)VzHTTP utility code shared by clients and servers. This module also defines the `HTTPServerRequest` class which is exposed via `tornado.web.RequestHandler.request`. N) lru_cache) responses)SSLError) urlencodeurlparse urlunparse parse_qsl) native_strparse_qs_bytesutf8) ObjectDict unicode_type) TupleIterableListMappingIteratorDictUnionOptional Awaitable GeneratorAnyStr)Deque)Futureinamereturncdj|jdDcgc]}|jc}Scc}w)ziMap a header name to Http-Header-Case. >>> _normalize_header("coNtent-TYPE") 'Content-Type' -)joinsplit capitalize)rws 2/usr/lib/python3/dist-packages/tornado/httputil.py_normalize_headerr%As/ 88TZZ_=Q\\^= >>=s=ceZdZdZej deeeefddfdZ ej deeefddfdZ ej de eefddfdZ ej d eddfd Z dejd eddfd Z d ed eddfdZ d edeefdZ dee eeffdZdeddfdZededdfdZd ed eddfdZd edefdZd eddfdZdefdZdeejfdZddZeZdefdZeZy) HTTPHeadersaA dictionary that maintains ``Http-Header-Case`` for all keys. Supports multiple values per key via a pair of new methods, `add()` and `get_list()`. The regular dictionary interface returns a single value per key, with multiple values joined by a comma. >>> h = HTTPHeaders({"content-type": "text/html"}) >>> list(h.keys()) ['Content-Type'] >>> h["Content-Type"] 'text/html' >>> h.add("Set-Cookie", "A=B") >>> h.add("Set-Cookie", "C=D") >>> h["set-cookie"] 'A=B,C=D' >>> h.get_list("set-cookie") ['A=B', 'C=D'] >>> for (k,v) in sorted(h.get_all()): ... print('%s: %s' % (k,v)) ... Content-Type: text/html Set-Cookie: A=B Set-Cookie: C=D _HTTPHeaders__argrNcyNselfr(s r$__init__zHTTPHeaders.__init__h cyr*r+r,s r$r.zHTTPHeaders.__init__lr/r0argscyr*r+)r-r2s r$r.zHTTPHeaders.__init__pr/r0kwargsc yr*r+)r-r4s r$r.zHTTPHeaders.__init__tr/r0c i|_i|_d|_t|dk(rOt|dk(rAt |dt r.|dj D]\}}|j||y|j|i|y)Nr) _dict_as_list _last_keylen isinstancer'get_alladdupdate)r-r2r4kvs r$r.zHTTPHeaders.__init__xsz   t9>c&kQ.:d1g{3SQ) 1A  DKK ( (r0rvaluect|}||_||vrIt||dzt|z|j|<|j|j |y|||<y)z#Adds a new value for the given key.,N)r%r:r r8r9appendr-rrB norm_names r$r>zHTTPHeaders.addsf%d+ "  4 ?+c1Ju4EE JJy ! MM) $ + +E 2#DOr0cPt|}|jj|gS)z2Returns all values for the given header as a list.)r%r9getr-rrGs r$get_listzHTTPHeaders.get_lists#%d+ }}  B//r0c#jK|jjD]\}}|D]}||f yw)zReturns an iterable of all (name, value) pairs. If a header has multiple values, multiple pairs will be returned with the same name. N)r9items)r-rvaluesrBs r$r=zHTTPHeaders.get_allsA !MM//1 $LD& $Um# $ $s13linec|djrp|j tdd|jz}|j|jdxx|z cc<|j |jxx|z cc<y |j dd\}}|j||jy#t$r tdwxYw) zUpdates the dictionary with a single header line. >>> h = HTTPHeaders() >>> h.parse_line("Content-Type: text/html") >>> h.get('content-type') 'text/html' rNz.first header line cannot start with whitespace :r7zno colon in header line) isspacer:HTTPInputErrorlstripr9r8r! ValueErrorr>strip)r-rOnew_partrrBs r$ parse_linezHTTPHeaders.parse_lines 7?? ~~%$%UVVT[[]*H MM$.. )" - 9 - JJt~~ &( 2 & @"jja0 e HHT5;;= ) @$%>?? @s B;;Cheadersc|}|jdD],}|jdr|dd}|s|j|.|S)aReturns a dictionary from HTTP header text. >>> h = HTTPHeaders.parse("Content-Type: text/html\r\nContent-Length: 42\r\n") >>> sorted(h.items()) [('Content-Length', '42'), ('Content-Type', 'text/html')] .. versionchanged:: 5.1 Raises `HTTPInputError` on malformed headers instead of a mix of `KeyError`, and `ValueError`.   NrR)r!endswithrZ)clsr[hrOs r$parsezHTTPHeaders.parsesR EMM$' #D}}T"CRy T"  # r0cXt|}||j|<|g|j|<yr*r%r8r9rFs r$ __setitem__zHTTPHeaders.__setitem__s*%d+ % 9$)7 i r0c2|jt|Sr*)r8r%)r-rs r$ __getitem__zHTTPHeaders.__getitem__szz+D122r0cNt|}|j|=|j|=yr*rdrJs r$ __delitem__zHTTPHeaders.__delitem__s$%d+ JJy ! MM) $r0c,t|jSr*)r;r8r-s r$__len__zHTTPHeaders.__len__s4::r0c,t|jSr*)iterr8rks r$__iter__zHTTPHeaders.__iter__sDJJr0ct|Sr*)r'rks r$copyzHTTPHeaders.copys 4  r0cg}|jD]\}}|j|d|ddj|S)Nz: r])r=rEr )r-linesrrBs r$__str__zHTTPHeaders.__str__s?<<> 5KD% LLtU3 4 5wwu~r0)rr')__name__ __module__ __qualname____doc__typingoverloadrstrrr.rAnyr>rKrr=rZ classmethodrbrergriintrlrrorq__copy__ru __unicode__r+r0r$r'r'Ks8 __ gc49n5 $   __ gc3h/ D   __ eCHo $   __     )fjj )C )D ) $ $C $D $0S0T#Y0 $%S/2$*s*t*,CM2++C+D+ 333%%%  (6::. !H Kr0r'c@eZdZdZdZdZdZ ddeedeededee dee deed ee ee d fd ed d eddee ddfdZede eej"j$ffdZdefdZdefdZ ddedede e ffdZddZdefdZy)HTTPServerRequesta7 A single HTTP request. All attributes are type `str` unless otherwise noted. .. attribute:: method HTTP request method, e.g. "GET" or "POST" .. attribute:: uri The requested uri. .. attribute:: path The path portion of `uri` .. attribute:: query The query portion of `uri` .. attribute:: version HTTP version specified in request, e.g. "HTTP/1.1" .. attribute:: headers `.HTTPHeaders` dictionary-like object for request headers. Acts like a case-insensitive dictionary with additional methods for repeated headers. .. attribute:: body Request body, if present, as a byte string. .. attribute:: remote_ip Client's IP address as a string. If ``HTTPServer.xheaders`` is set, will pass along the real IP address provided by a load balancer in the ``X-Real-Ip`` or ``X-Forwarded-For`` header. .. versionchanged:: 3.1 The list format of ``X-Forwarded-For`` is now supported. .. attribute:: protocol The protocol used, either "http" or "https". If ``HTTPServer.xheaders`` is set, will pass along the protocol used by a load balancer if reported via an ``X-Scheme`` header. .. attribute:: host The requested hostname, usually taken from the ``Host`` header. .. attribute:: arguments GET/POST arguments are available in the arguments property, which maps arguments names to lists of values (to support multiple values for individual names). Names are of type `str`, while arguments are byte strings. Note that this is different from `.RequestHandler.get_argument`, which returns argument values as unicode strings. .. attribute:: query_arguments Same format as ``arguments``, but contains only arguments extracted from the query string. .. versionadded:: 3.2 .. attribute:: body_arguments Same format as ``arguments``, but contains only arguments extracted from the request body. .. versionadded:: 3.2 .. attribute:: files File uploads are available in the files property, which maps file names to lists of `.HTTPFile`. .. attribute:: connection An HTTP request is attached to a single HTTP connection, which can be accessed through the "connection" attribute. Since connections are typically kept open in HTTP/1.1, multiple requests can be handled sequentially on a single connection. .. versionchanged:: 4.0 Moved from ``tornado.httpserver.HTTPRequest``. Nmethoduriversionr[bodyhostfilesHTTPFile connectionHTTPConnection start_lineRequestStartLineserver_connectionrc | | \}}}||_||_||_|xs t|_|xsd|_t |dd} t | dd|_t | dd|_|xs|jjdxsd|_ t|jjd|_ |xsi|_||_| |_t#j"|_d|_||j)d \|_} |_t/|j,d |_t3j4|j0|_i|_y) Nr0context remote_ipprotocolhttpHostz 127.0.0.1r?Tkeep_blank_values)rrrr'r[rgetattrrrrIrsplit_host_and_portlower host_namerrrtime _start_time _finish_time partitionpathqueryr argumentsrqdeepcopyquery_argumentsbody_arguments) r-rrrr[rrrrrrrseps r$r.zHTTPServerRequest.__init__Ys-  !#- FC  /+- KC *i6 +t<V< CDLL,,V4C  ,TYY__->?B[b $!299;  ?),s); &DIsDJ' dK#}}T^^< r0ct|ds~tjj|_d|j vrM t |j d}|jD]\}} ||j|<|jS|jS#t$rY;wxYw#t$rY|jSwxYw)z0A dictionary of ``http.cookies.Morsel`` objects._cookiesCookie) hasattrrcookies SimpleCookierr[ parse_cookierM Exception)r-parsedr@rAs r$rzHTTPServerRequest.cookiesstZ( ))+ M4<<' !)$,,x*@AF!' !1!/0DMM!,!}}t}} )!! ! !}}s#B&.B B#"B#& B=<B=cT|jdz|jz|jzS)z+Reconstructs the full URL for this request.z://)rrrrks r$full_urlzHTTPServerRequest.full_urls#}}u$tyy0488;;r0c|j!tj|jz S|j|jz S)z?Returns the amount of time it took for this request to execute.)rrrrks r$ request_timezHTTPServerRequest.request_times<    $99;!1!11 1$$t'7'77 7r0 binary_formc |jy|jjjj|S#t$rYywxYw)a>Returns the client's SSL certificate, if any. To use client certificates, the HTTPServer's `ssl.SSLContext.verify_mode` field must be set, e.g.:: ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_ctx.load_cert_chain("foo.crt", "foo.key") ssl_ctx.load_verify_locations("cacerts.pem") ssl_ctx.verify_mode = ssl.CERT_REQUIRED server = HTTPServer(app, ssl_options=ssl_ctx) By default, the return value is a dictionary (or None, if no client certificate is present). If ``binary_form`` is true, a DER-encoded form of the certificate is returned instead. See SSLSocket.getpeercert() in the standard library for more details. http://docs.python.org/library/ssl.html#sslsocket-objects N)r)rstreamsocket getpeercertr)r-rs r$get_ssl_certificatez%HTTPServerRequest.get_ssl_certificatesS* &??))00<<'=   s ?/? A  A c@t|jjdd|j|j|j |j|jj D]0\}}|jj|gj|2y)N Content-Typers) parse_body_argumentsr[rIrrrrMr setdefaultextend)r-r@rAs r$ _parse_bodyzHTTPServerRequest._parse_bodys LL  ^R 0 II    JJ LL  ''--/ 7DAq NN % %a , 3 3A 6 7r0c d}dj|Dcgc]}|dt||c}}|jjd|dScc}w)N)rrrrrrz, =())r r __class__rv)r-attrsnr2s r$__repr__zHTTPServerRequest.__repr__sGMyy5IaQa(89IJ>>22D99JsA ) NNzHTTP/1.0NNNNNNN)FrN)rvrwrxryrr _body_futurerr|r'bytesrrobjectr.propertyrrMorselrfloatrboolrrrrr+r0r$rrsfZx D EL!%!!)- $"7;1537.2&! &!c]&! &! +& &! uo &!sm&!S$z"2234&!-.&!/0&!$F+&! &!Pc4<<#6#667,<#<8e8#( tT5 !> 7:#:r0rceZdZdZy)rUzqException class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0 Nrvrwrxryr+r0r$rUrUs   r0rUceZdZdZy)HTTPOutputErrorzJException class for errors in HTTP output. .. versionadded:: 4.0 Nrr+r0r$rrs   r0rc4eZdZdZdeddddfdZdeddfd Zy) HTTPServerConnectionDelegatez_Implement this interface to handle requests from `.HTTPServer`. .. versionadded:: 4.0 server_conn request_connrrHTTPMessageDelegatect)ajThis method is called by the server when a new request has started. :arg server_conn: is an opaque object representing the long-lived (e.g. tcp-level) connection. :arg request_conn: is a `.HTTPConnection` object for a single request/response exchange. This method should return a `.HTTPMessageDelegate`. NotImplementedError)r-rrs r$ start_requestz*HTTPServerConnectionDelegate.start_requests "##r0Ncy)zThis method is called when a connection has been closed. :arg server_conn: is a server connection that has previously been passed to ``start_request``. Nr+)r-rs r$on_closez%HTTPServerConnectionDelegate.on_close r0)rvrwrxryrrrr+r0r$rrs7 $! $1A $  $ F t r0rcbeZdZdZdeddedeedfdZde deedfd Z d d Z d d Z y) rz_Implement this interface to handle an HTTP request or response. .. versionadded:: 4.0 rrResponseStartLiner[rNcy)aCalled when the HTTP headers have been received and parsed. :arg start_line: a `.RequestStartLine` or `.ResponseStartLine` depending on whether this is a client or server message. :arg headers: a `.HTTPHeaders` instance. Some `.HTTPConnection` methods can only be called during ``headers_received``. May return a `.Future`; if it does the body will not be read until it is done. Nr+)r-rr[s r$headers_receivedz$HTTPMessageDelegate.headers_received s" r0chunkcy)ziCalled when a chunk of data has been received. May return a `.Future` for flow control. Nr+r-rs r$ data_receivedz!HTTPMessageDelegate.data_receiveds r0cy)z6Called after the last chunk of data has been received.Nr+rks r$finishzHTTPMessageDelegate.finish%r/r0cy)zCalled if the connection is closed without finishing the request. If ``headers_received`` is called, either ``finish`` or ``on_connection_close`` will be called, but not both. Nr+rks r$on_connection_closez'HTTPMessageDelegate.on_connection_close)rr0r) rvrwrxryrr'rrrrrrrr+r0r$rrs]  AB   )D/ "  & 5 Xio-F   r0rc PeZdZdZ d deddedeeddfd Zdeddfd Z d d Z y)rzYApplications use this interface to write their responses. .. versionadded:: 4.0 Nrrr[rrz Future[None]ct)aWrite an HTTP header block. :arg start_line: a `.RequestStartLine` or `.ResponseStartLine`. :arg headers: a `.HTTPHeaders` instance. :arg chunk: the first (optional) chunk of data. This is an optimization so that small responses can be written in the same call as their headers. The ``version`` field of ``start_line`` is ignored. Returns a future for flow control. .. versionchanged:: 6.0 The ``callback`` argument was removed. r)r-rr[rs r$ write_headerszHTTPConnection.write_headers8s ,"##r0ct)zWrites a chunk of body data. Returns a future for flow control. .. versionchanged:: 6.0 The ``callback`` argument was removed. rrs r$writezHTTPConnection.writePs "##r0ct)z3Indicates that the last body data has been written.rrks r$rzHTTPConnection.finish[s !##r0r*r) rvrwrxryrr'rrrrrr+r0r$rr2sY"& $AB$$ $  $0 $5 $^ $$r0rurlr2.c ||St|}t|tr7t|jd}|j |j nnt|tst|tr)t|jd}|j |n%djt|}t|t|}t|d|d|d|d||df}|S) aConcatenate url and arguments regardless of whether url has existing query parameters. ``args`` may be either a dictionary or a list of key-value pairs (the latter allows for multiple values with the same key. >>> url_concat("http://example.com/foo", dict(c="d")) 'http://example.com/foo?c=d' >>> url_concat("http://example.com/foo?a=b", dict(c="d")) 'http://example.com/foo?a=b&c=d' >>> url_concat("http://example.com/foo?a=b", [("c", "d"), ("c", "d2")]) 'http://example.com/foo?a=b&c=d&c=d2' Trz7'args' parameter should be dict, list or tuple. Not {0}rr7)rr<dictr rrrMlisttupleformattype TypeErrorrr)rr2 parsed_url parsed_queryerr final_querys r$ url_concatr`s& | #J$ !1!1TJ DJJL) D$ :dE#: !1!1TJ D!GNN J nL)K  qM qM qM qM  qM   C Jr0c0eZdZUdZeed<eed<eed<y)rzRepresents a file uploaded via a form. For backwards compatibility, its instance attributes are also accessible as dictionary keys. * ``filename`` * ``body`` * ``content_type`` filenamer content_typeN)rvrwrxryr|__annotations__rr+r0r$rrsM Kr0r range_headerc$|jd\}}}|j|j}}|dk7ry|jd\}}} t|}t|}|||dk7r| }d}||fS|dz }||fS#t$rYywxYw)agParses a Range header. Returns either ``None`` or tuple ``(start, end)``. Note that while the HTTP headers use inclusive byte positions, this method returns indexes suitable for use in slices. >>> start, end = _parse_request_range("bytes=1-2") >>> start, end (1, 3) >>> [0, 1, 2, 3, 4][start:end] [1, 2] >>> _parse_request_range("bytes=6-") (6, None) >>> _parse_request_range("bytes=-6") (-6, None) >>> _parse_request_range("bytes=-0") (None, 0) >>> _parse_request_range("bytes=") (None, None) >>> _parse_request_range("foo=42") >>> _parse_request_range("bytes=1-2,6-10") Note: only supports one range (ex, ``bytes=1-2,6-10`` is not allowed). See [0] for the details of the range header. [0]: http://greenbytes.de/tech/webdav/draft-ietf-httpbis-p5-range-latest.html#byte.ranges rrNrrr7)rrX _int_or_nonerW)runit_rBstart_bend_bstartends r$_parse_request_rangers>"++C0ND!U**, %D w,GQW%5!  =ax 3< 1HC 3< sB BBrrtotalc6|xsd}|xs|dz }d|d|d|S)zReturns a suitable Content-Range header: >>> print(_get_content_range(None, 1, 4)) bytes 0-0/4 >>> print(_get_content_range(1, 3, 4)) bytes 1-2/4 >>> print(_get_content_range(None, None, 4)) bytes 0-3/4 rr7zbytes r/r+)rrrs r$_get_content_rangers( JQE <%1 C$c5 11r0valcD|j}|dk(ryt|S)Nrs)rXr)rs r$r r s ))+C by s8Or0rrrrr[c|jdrb|rd|vrtd|dz t|d}|j D])\}}|s |j |gj |+y|jdr|rd|vrtd|dz |jd } | D]F} | jjd \} } } | d k(s,| s/tt| |||ytd y#t$r}td|z|d}~wwxYw#t$r}td |z|d}~wwxYw)aFParses a form request body. Supports ``application/x-www-form-urlencoded`` and ``multipart/form-data``. The ``content_type`` parameter should be a string and ``body`` should be a byte string. The ``arguments`` and ``files`` parameters are dictionaries that will be updated with the parsed contents. z!application/x-www-form-urlencodedzContent-Encodingz Unsupported Content-Encoding: %sTrz&Invalid x-www-form-urlencoded body: %sNzmultipart/form-data;rboundaryzmultipart boundary not foundzInvalid multipart/form-data: %s) startswithrUr rrMrrr!rXrparse_multipart_form_datar )rrrrr[ uri_argumentserrNfieldsfieldr@rrAs r$rrsBC )W4 2W=O5PP  V*44HM*//1 >LD&$$T2.55f= >  !6 7 )W4 2W=O5PP  O!'',F E!KKM33C8 3 ?q-d1gtYN  E %%CDD 8  V !IA!MNTU U V& O !BQ!FGQ N OsA D>D%D%D%8 D% D"DD"% E.D==Erdatac<|jdr|jdr|dd}|jd|zdz}|dk(r td|d|j d|zdz}|D].}|s|j d}|dk(r td t j|d|jd }|jd d } t| \} } | d k7s|jds td||dzd} | jds td| d} | jdrD|jdd}|j| gjt| d| ||j| gj| 1y)a]Parses a ``multipart/form-data`` body. The ``boundary`` and ``data`` parameters are both byte strings. The dictionaries given in the arguments and files parameters will be updated with the contents of the body. .. versionchanged:: 5.1 Now recognizes non-ASCII filenames in RFC 2231/5987 (``filename*=``) format. "r7rRs--z4Invalid multipart/form-data: no final boundary foundNs s z#multipart/form-data missing headerszutf-8zContent-Dispositionrsz form-datazInvalid multipart/form-datarz multipart/form-data missing namerrzapplication/unknown)rrr)rr_rfindrUr!findr'rbdecoderI _parse_headerrrEr)rr!rrfinal_boundary_indexpartsparteohr[ disp_header disposition disp_paramsrBrctypes r$rrs,4 X%6%6t%<Ab>::eh&6&>?r!STT && ' - -eh.>.H IE9 ii $ "9 !FG G##D#J$5$5g$>?kk"7< #0#= [ + %T]]7-C !>? ?S1Wr"v& !CD D6" ??: &KK0EFE   T2 & - -(45u   r * 1 1% 8/9r0tsczt|ttfr|}nt|ttj frt j|}nLt|tjr$t j|j}ntd|ztjj|dS)aFormats a timestamp in the format used by HTTP. The argument may be a numeric timestamp as returned by `time.time`, a time tuple as returned by `time.gmtime`, or a `datetime.datetime` object. Naive `datetime.datetime` objects are assumed to represent UTC; aware objects are converted to UTC before formatting. >>> format_timestamp(1359312200) 'Sun, 27 Jan 2013 18:43:20 GMT' zunknown timestamp type: %rT)usegmt)r<rrrr struct_timecalendartimegmdatetime utctimetupleremailutils formatdate)r2time_nums r$format_timestampr>Ls"sEl# B 0 01 2??2& B)) *??2??#454r9:: ;; ! !(4 ! 88r0r)rrrz^HTTP/1\.[0-9]$rOc |jd\}}}tj |std|zt |||S#t$r tdwxYw)zReturns a (method, path, version) tuple for an HTTP 1.x request line. The response is a `collections.namedtuple`. >>> parse_request_start_line("GET /foo HTTP/1.1") RequestStartLine(method='GET', path='/foo', version='HTTP/1.1') rQzMalformed HTTP request linez/Malformed HTTP version in HTTP Request-Line: %r)r!rWrU_http_version_rematchr)rOrrrs r$parse_request_start_linerBlsp< $ 3g  ! !' * = G   FD' 22 <:;;>> parse_response_start_line("HTTP/1.1 200 OK") ResponseStartLine(version='HTTP/1.1', code=200, reason='OK') z!Error parsing response start liner7rr)r _http_response_line_rerArUrgroupr)rOrAs r$parse_response_start_linerHsY d D " ( ( .E @AA U[[^SQ-@%++a. QQr0sc#K|dddk(r|dd}|jd}|dkDro|jdd||jdd|z dzrE|jd|dz}|dkDr+|jdd||jdd|z dzrE|dkr t|}|d|}|j||d}|dddk(ryyw)Nr7rr"z\"r)r'countr;rX)rIrfs r$ _parseparamrNs BQ%3, abEffSkAg17733/!''%C2HHAM&&cAg&CAg17733/!''%C2HHAM 7a&C dsGggi cdG BQ%3,sBC 4C  C c*td|z}t|}dg}|D]l}|jd}|dk\s|d|jj }||dzdj}|j |t |fntjj|}|jdi} |D]L\}} tjj| }t|dk\r|ddk(r |d dk(r|dd }|| |<N|| fS) aYParse a Content-type like header. Return the main content-type and a dictionary of options. >>> d = "form-data; foo=\"b\\\\a\\\"r\"; file*=utf-8''T%C3%A4st" >>> ct, d = _parse_header(d) >>> ct 'form-data' >>> d['file'] == r'T\u00e4st'.encode('ascii').decode('unicode_escape') True >>> d['foo'] 'b\\a"r' r)DummyrBrrNr7rrKrR) rNnextr'rXrrEr r:r; decode_paramspopcollapse_rfc2231_valuer;) rOr+keyparamspirrBdecoded_paramspdict decoded_values r$r)r)s d #E u+C !F 5 FF3K 6Ra5;;=&&(Da!egJ$$&E MM4E!23 4 5 [[..v6Nq E-m 22=A u:?uQx3593C!BKEd  :r0rUrZc|s|S|g}t|jD]/\}}||j||j|d|1dj|S)zInverse of _parse_header. >>> _encode_header('permessage-deflate', ... {'client_max_window_bits': 15, 'client_no_context_takeover': None}) 'permessage-deflate; client_max_window_bits=15; client_no_context_takeover' rz; )sortedrMrEr )rUrZoutr@rAs r$_encode_headerr_sd  %Cu{{}%)1 9 JJqM JJ!Q' ( ) 99S>r0usernamepasswordct|trtjd|}t|trtjd|}t |dzt |zS)zEncodes a username/password pair in the format used by HTTP auth. The return value is a byte string in the form ``username:password``. .. versionadded:: 5.1 NFC:)r<r unicodedata normalizer )r`ras r$encode_username_passwordrgsT(L)((9(L)((9 >D 4> 11r0c*ddl}|jS)Nr)doctest DocTestSuite)ris r$doctestsrks    !!r0z ^(.+):(\d+)$netlocctj|}|r/|jd}t|jd}||fS|}d}||fS)zReturns ``(host, port)`` tuple from ``netloc``. Returned ``port`` will be ``None`` if not present. .. versionadded:: 4.1 r7rN) _netloc_rerArGr)rlrArports r$rrsX   V $E {{1~5;;q>" $< $<r0qsc#VK|jD]\}}|D]}||f yw)zgGenerator converting a result of ``parse_qs`` back to name-value pairs. .. versionadded:: 5.0 N)rM)rpr@vsrAs r$ qs_to_qslrss9 2 Aa&L s')z\\(?:([0-3][0-7][0-7])|(.))mcF|drtt|ddS|dS)Nr7r)chrr)rts r$_unquote_replacerxs't3qtQ<  t r0ct|t|dkr|S|ddk7s|ddk7r|S|dd}tt|S)zHandle double quotes and escaping in cookie values. This method is copied verbatim from the Python 3.13 standard library (http.cookies._unquote) so we don't have to depend on non-public interfaces. rrrKrRr7)r; _unquote_subrx)rIs r$_unquote_cookier{#sO yCFQJts{aesl !BA (! ,,r0cookiec i}|jtdD]n}td|vr|jtdd\}}n td|}}|j|j}}|s|sat|||<p|S)a[Parse a ``Cookie`` HTTP header into a dict of name/value pairs. This function attempts to mimic browser cookie parsing behavior; it specifically does not follow any of the cookie-related RFCs (because browsers don't either). The algorithm used is identical to that used by Django version 1.9.10. .. versionadded:: 4.4.2 rrr7rs)r!r|rXr{)r| cookiedictrrUrs r$rr>sJc#h' 3 s8u {{3s8Q/HC2wC99; S #-c2JsO 3 r0r*)`ryr6collections.abc collectionsrqr8 email.utilsr: functoolsr http.clientr http.cookiesrresslrrre urllib.parserrrr tornado.escaper r r tornado.utilr rrzrrrrrrrrrrr TYPE_CHECKINGrasynciorunittestr|r%abcMutableMappingr'rrrrUrrrrrrrrrr rrrrrr5r> namedtuplercompiler@rBrrFrHrNr)r_rgrkrnrrssubrzMatchrxr{rr+r0r$rs   !  CC;;1        4?C?C??h+//00hV[:[:| Y  i  6 :+ &+ \+$V+$\, ,  d38nd5c?3U5c?C;O5PP ,  ,^ z  00 eHSM8C=0120f 2hsm 2(3- 2 2PS 2chsm&* +O+O +OCe$%+O T(^# $ +O k " +O  +O\3939 39Ce$%39 T(^# $ 39  39l9 c5%!1!183D3DDE990*;))5 2::01333+;3*+K**6 $$GH RC R,= R. 3 9S$_5   c4S>&9 : FDcNs( 2CJ 2+0e+< 2  2 "RZZ ( c8C=.@(A"$sDL()huS&[7I.Jrzz89== S-s-s-6c3hr0