g; dZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl Z ddlZddlmZddlZddlZddlmZmZmZmZddlmZmZmZddlmZdd lmZm Z e ddl!Z!dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,e!jZrdd l!m.Z.dd l/m0Z0ddl1Z1d Z2e dde3de3fdZ4GddejjjlZ7Gdde8Z9Gdde:Z;Gdde:Z<Gdde8Z=Gdde8Z>Gdde8Z?d e3d!e(de'e3e3fe$e"e3e3fe"e"e3e3fd"ffde3fd#Z@Gd$d%eZAd&e3de)e"e)eBe)eBffd'ZCd(e)eBd)e)eBd*eBde3fd+ZDd,e3de)eBfd-ZE dWd.e3d/eFd0e'e3e$eFfd1e'e3e$eAfd2e)e7ddf d3ZGd4eFd5eFd0e'e3e$eFfd1e'e3e$eAfddf d6ZHd7e(eBeIeJejej fde3fd8ZLejd9gd:ZNejd;ZPdgd?ZRejd@ZSd>> _normalize_header("coNtent-TYPE") 'Content-Type' -)joinsplit capitalize)rws E/var/www/openai/venv/lib/python3.12/site-packages/tornado/httputil.py_normalize_headerr&Es3 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__l cyr+r,r-s r%r/zHTTPHeaders.__init__pr0r1argscyr+r,)r.r3s r%r/zHTTPHeaders.__init__tr0r1kwargsc yr+r,)r.r5s r%r/zHTTPHeaders.__init__xr0r1c 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.r3r5kvs r%r/zHTTPHeaders.__init__|su   t9>c&kQ.:d1g{3SQ)1A* DKK ( (r1rvaluect|}||_||vrIt||dzt|z|j|<|j|j |y|||<y)z#Adds a new value for the given key.,N)r&r;r r9r:appendr.rrC norm_names r%r?zHTTPHeaders.addsf%d+ "  4 ?+c1Ju4EE JJy ! MM) $ + +E 2#DOr1cPt|}|jj|gS)z2Returns all values for the given header as a list.)r&r:getr.rrHs r%get_listzHTTPHeaders.get_lists#%d+ }}  B//r1c#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)r:items)r.rvaluesrCs r%r>zHTTPHeaders.get_alls7 !MM//1LD&Um# 2s13linec|djru|j tdd|jtz}|j |jdxx|z cc<|j |jxx|z cc<y |jdd\}}|j||jty#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 :r8zno colon in header line) isspacer;HTTPInputErrorlstripHTTP_WHITESPACEr:r9r" ValueErrorr?strip)r.rPnew_partrrCs r% parse_linezHTTPHeaders.parse_lines 7?? ~~%$%UVVT[[99H MM$.. )" - 9 - JJt~~ &( 2 & @"jja0 e HHT5;;7 8 @$%>?? @s CCheadersc|}|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`.   NrS)r"endswithr\)clsr]hrPs r%parsezHTTPHeaders.parsesM EMM$'D}}T"CRy T" ( r1cXt|}||j|<|g|j|<yr+r&r9r:rGs r% __setitem__zHTTPHeaders.__setitem__s*%d+ % 9$)7 i r1c2|jt|Sr+)r9r&)r.rs r% __getitem__zHTTPHeaders.__getitem__szz+D122r1cNt|}|j|=|j|=yr+rfrKs r% __delitem__zHTTPHeaders.__delitem__s$%d+ JJy ! MM) $r1c,t|jSr+)r<r9r.s r%__len__zHTTPHeaders.__len__s4::r1c,t|jSr+)iterr9rms r%__iter__zHTTPHeaders.__iter__sDJJr1ct|Sr+)r(rms r%copyzHTTPHeaders.copys 4  r1cg}|jD]\}}|j|d|ddj|S)Nz: r_)r>rFr!)r.linesrrCs r%__str__zHTTPHeaders.__str__s:<<>KD% LLtU3 4*wwu~r1)rr()__name__ __module__ __qualname____doc__typingoverloadrstrrr/rAnyr?rLrr>r\ classmethodrdrgrirkintrnrrqrs__copy__rw __unicode__r,r1r%r(r(Os8 __ gc49n5 $   __ gc3h/ D   __ eCHo $   __     )fjj )C )D ) $ $C $D $0S0T#Y0 $%S/2$9s9t9,CM2++C+D+ 333%%%  (6::. !H Kr1r(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) Nr1context remote_ipprotocolhttpHostz 127.0.0.1r?Tkeep_blank_values)rrrr(r]rgetattrrrrJrsplit_host_and_portlower host_namerrrtime _start_time _finish_time partitionpathqueryr argumentsrsdeepcopyquery_argumentsbody_arguments) r.rrrr]rrrrrrrseps r%r/zHTTPServerRequest.__init__]s-  !#- FC  /+- KC *i6 +t<V< CDLL,,V4C  ,TYY__->?B[b $!299;  ?),s); &DIsDJ' dK#}}T^^< r1ct|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_cookierN Exception)r.parsedrArBs 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://)rrrrms r%full_urlzHTTPServerRequest.full_urls#}}u$tyy0488;;r1c|j!tj|jz S|j|jz S)z?Returns the amount of time it took for this request to execute.)rrrrms r% request_timezHTTPServerRequest.request_times<    $99;!1!11 1$$t'7'77 7r1 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-Typeru) parse_body_argumentsr]rJrrrrNr setdefaultextend)r.rArBs r% _parse_bodyzHTTPServerRequest._parse_bodysz LL  ^R 0 II    JJ LL  ''--/DAq NN % %a , 3 3A 60r1c d}dj|Dcgc]}|dt||c}}|jjd|dScc}w)N)rrrrrrz, =())r!r __class__rx)r.attrsnr3s r%__repr__zHTTPServerRequest.__repr__sKMyy5I5aQa(895IJ>>22D99JsA ) NNzHTTP/1.0NNNNNNN)FrN)rxryrzr{rr _body_futurerr~r(bytesrrobjectr/propertyrrMorselrfloatrboolrrrrr,r1r%rrsfZx D EL!%!!)- $"7;1537.2&! &!c]&! &! +& &! uo &!sm&!S$z"2234&!-.&!/0&!$F+&! &!Pc4<<#6#667,<#<8e8#( tT5 !> 7:#:r1rceZdZdZy)rVzqException class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0 Nrxryrzr{r,r1r%rVrVs   r1rVceZdZdZy)HTTPOutputErrorzJException class for errors in HTTP output. .. versionadded:: 4.0 Nrr,r1r%rrs   r1rc4eZdZdZdeddddfdZdeddfd 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 "##r1Ncy)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 r1)rxryrzr{rrrr,r1r%rrs7 $! $1A $  $ F t r1rcbeZdZdZdeddedeedfdZde 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_receiveds" r1chunkcy)ziCalled when a chunk of data has been received. May return a `.Future` for flow control. Nr,r.rs r% data_receivedz!HTTPMessageDelegate.data_received"s r1cy)z6Called after the last chunk of data has been received.Nr,rms r%finishzHTTPMessageDelegate.finish)r0r1cy)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,rms r%on_connection_closez'HTTPMessageDelegate.on_connection_close-rr1r) rxryrzr{rr(rrrrrrrr,r1r%rrs]  AB   )D/ "  & 5 Xio-F   r1rc 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_headers<s ,"##r1ct)zWrites a chunk of body data. Returns a future for flow control. .. versionchanged:: 6.0 The ``callback`` argument was removed. rrs r%writezHTTPConnection.writeTs "##r1ct)z3Indicates that the last body data has been written.rrms r%rzHTTPConnection.finish_s !##r1r+r) rxryrzr{rr(rrrrrr,r1r%rr6sY"& $AB$$ $  $0 $5 $^ $$r1rurlr3.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}rr8)rr=dictr rrrNlisttupleformattype TypeErrorrr)rr3 parsed_url parsed_queryerr final_querys r% url_concatrds& | #J$ !1!1TJ DJJL) D$ :dE#: !1!1TJ D!GNN J nL)K  qM qM qM qM  qM   C Jr1c0eZdZUdZeed<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)rxryrzr{r~__annotations__rr,r1r%rrsM Kr1r 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 rrNr rr8)rrZ _int_or_nonerY)r unit_rCstart_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 rr8zbytes r /r,)rrrs r%_get_content_rangers( JQE <%1 C$c5 11r1valcD|j}|dk(ryt|S)Nru)rZr)rs r%r r s ))+C by s8Or1rrrrr]c|jdrk|rd|vrtjd|dy t|d}|j D])\}}|s |j |gj|+y|jdr|rd|vrtjd|dy |jd } | D]F} | jjd \} } } | d k(s,| s/tt| |||ytd y#t$r"}tjd|i}Yd}~d}~wwxYw#t$r }tjd |Yd}~yd}~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: %sNTrz&Invalid x-www-form-urlencoded body: %szmultipart/form-data;rboundaryzmultipart boundary not foundzInvalid multipart/form-data: %s) startswithr warningr rrNrrr"rZrparse_multipart_form_datar rY)rrrrr] uri_argumentserrOfieldsfieldrArrBs r%rrsrBC )W4 OO2GE.E1E E E D==E E.E))E.rdatac|jdr|jdr|dd}|jd|zdz}|dk(rtjdy|d|j d|zdz}|D]O}|s|j d}|dk(rtjd 3tj|d|jd }|jd d } t| \} } | d k7s|jdstjd||dzd} | jdstjd| d} | jdrD|jdd}|j| gjt| d| |/|j| gj| Ry)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. "r8rSs--z.Invalid multipart/form-data: no final boundaryNs s z#multipart/form-data missing headerszutf-8zContent-Dispositionruz form-datazInvalid multipart/form-datarz&multipart/form-data value missing namerrzapplication/unknown)rrr)rrarfindr rr"findr(rddecoderJ _parse_headerrrFr)rr$rrfinal_boundary_indexpartsparteohr] disp_header disposition disp_paramsrCrctypes r%rrs,4 X%6%6t%<Ab>::eh&6&>?r!HI && ' - -eh.>.H IE ii $ "9 OOA B ##D#J$5$5g$>?kk"7< #0#= [ + %T]]7-C OO9 : S1Wr"v& OOD E 6" ??: &KK0EFE   T2 & - -(45u   r * 1 1% 85r1tsczt|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)r5time_nums r%format_timestamprAWs"sEl# B 0 01 2??2& B)) *??2??#454r9:: ;; ! !(4 ! 88r1r)rrrz^HTTP/1\.[0-9]$rPc |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') rRzMalformed HTTP request linez/Malformed HTTP version in HTTP Request-Line: %r)r"rYrV_http_version_rematchr)rPrrrs r%parse_request_start_linerEwsp< $ 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 liner8rr)r _http_response_line_rerDrVrgroupr)rPrDs r%parse_response_start_linerKsY d D " ( ( .E @AA U[[^SQ-@%++a. QQr1sc#K|dddk(r|dd}|jd}|dkDro|jdd||jdd|z dzrE|jd|dz}|dkDr+|jdd||jdd|z dzrE|dkr t|}|d|}|j||d}|dddk(ryyw)Nr8rr"z\"r)r*countr<rZ)rLrfs r% _parseparamrQs 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)DummyrCrrNr8rrNrS) rQnextr*rZrrFr r=r> decode_paramspopcollapse_rfc2231_valuer<) rPr.keyparamspirrCdecoded_paramspdict decoded_values r%r,r,s d #E u+C !F  FF3K 6Ra5;;=&&(Da!egJ$$&E MM4E!23 4  [[..v6Nq E-m 22=A u:?uQx3593C!BKEd . :r1rXr]c|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; )sortedrNrFr!)rXr]outrArBs r%_encode_headerrbs_  %Cu{{}%1 9 JJqM JJ!Q' ( & 99S>r1usernamepasswordct|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 )rcrds r%encode_username_passwordrjsT(L)((9(L)((9 >D 4> 11r1c*ddl}|jS)Nr)doctest DocTestSuite)rls r%doctestsrns    !!r1z ^(.+):(\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 r8rN) _netloc_rerDrJr)rorDrports r%rr sX   V $E {{1~5;;q>" $< $<r1qsc#VK|jD]\}}|D]}||f yw)zgGenerator converting a result of ``parse_qs`` back to name-value pairs. .. versionadded:: 5.0 N)rN)rsrAvsrBs r% qs_to_qslrvs/ 2Aa&Ls')z\\(?:([0-3][0-7][0-7])|(.))mcF|drtt|ddS|dS)Nr8r)chrr)rws r%_unquote_replacer{'s't3qtQ<  t r1ct|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. rrrNrSr8)r< _unquote_subr{)rLs r%_unquote_cookier~.sO yCFQJts{aesl !BA (! ,,r1cookiec 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 rrr8ru)r"r~rZr~)r cookiedictrrXrs r%rrIsJc#h' s8u {{3s8Q/HC2wC99; S #-c2JsO( r1r+)cr{r9collections.abc collectionsrsr; email.utilsr= functoolsr http.clientr http.cookiesrresslrrrh urllib.parserrrr tornado.escaper r r tornado.logr tornado.utilrrr|rrrrrrrrrrr TYPE_CHECKINGrasynciorunittestrXr~r&abcMutableMappingr(rrrrVrrrrrrrrrr rrrrrr8rA namedtuplercompilerCrErrIrKrQr,rbrjrnrqrrvsubr}Matchr{r~rr,r1r%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&* .B.B .BCe$%.B T(^# $ .B k " .B  .Bb7979 79Ce$%79 T(^# $ 79  79t9 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-6c3hr1