a Df @s>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!j-r dd l!m.Z.dd l/m0Z0ddl1Z1e d e2e2dddZ3Gdddej4j5Z6Gddde7Z8Gddde9Z:Gddde9Z;Gddde7Ze2e(de'e2e2fe$e"e2e2fe"e"e2e2fdffe2d d!d"Z?Gd#d$d$eZ@e2e)e"e)eAe)eAfd%d&d'ZBe)eAe)eAeAe2d(d)d*ZCe2e)eAd+d,d-ZDd^e2eEe'e2e$eEfe'e2e$e@fe)e6dd.d/d0ZFeEeEe'e2e$eEfe'e2e$e@fdd1d2d3ZGe(eAeHeIejJejfe2d4d5d6ZKeLd7gd8ZMeNd9ZOe2eMd:d;d<ZPeLd=gd>ZQeNd?ZRe2eQd:d@dAZSe2e+e2ddfdBdCdDZTe2e"e2e'e2e2ffd:dEdFZUe2e'e2e2fe2dGdHdIZVe(e2eEfe(e2eEfeEdJdKdLZWdMdNZXeNdOZYe2e"e2e)eAfdPdQdRZZe'e2e$e,fe#e"e2e,fdSdTdUZ[eNdVZ\eNdWZ]dXj^Z_e2e2dBdYdZZ`e2e'e2e2fd[d\d]ZadS)_zHTTP 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)gen_log) ObjectDict unicode_type) TupleIterableListMappingIteratorDictUnionOptional Awaitable GeneratorAnyStr)Deque)FutureinamereturncCsddd|dDS)ziMap a header name to Http-Header-Case. >>> _normalize_header("coNtent-TYPE") 'Content-Type' -cSsg|] }|qS) capitalize).0wr r ]/nfs/NAS7/SABIOD/METHODE/ermites/ermites_venv/lib/python3.9/site-packages/tornado/httputil.py Iz%_normalize_header..)joinsplit)rr r r$_normalize_headerBsr)c@steZdZdZejeeeefddddZ ejeeefddddZ eje eefddddZ ejedd d dZ ej edd d dZ eedd ddZ eeedddZ ee eefdddZeddddZeeddddZeedd ddZeedddZeddd d!Zedd"d#Zeej dd$d%Zddd&d'ZeZedd(d)ZeZdS)* 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 N)_HTTPHeaders__argrcCsdSNr selfr+r r r$__init__iszHTTPHeaders.__init__cCsdSr,r r-r r r$r/ms)argsrcGsdSr,r )r.r0r r r$r/qs)kwargsrcKsdSr,r )r.r1r r r$r/us)r0r1rcOspi|_i|_d|_t|dkr\t|dkr\t|dtr\|dD]\}}|||qDn|j|i|dS)Nr) _dict_as_list _last_keylen isinstancer*get_alladdupdate)r.r0r1kvr r r$r/ys&)rvaluercCsRt|}||_||vrFt||dt||j|<|j||n|||<dS)z#Adds a new value for the given key.,N)r)r5r r3r4appendr.rr= norm_namer r r$r9szHTTPHeaders.addrcCst|}|j|gS)z2Returns all values for the given header as a list.)r)r4getr.rrAr r r$get_listszHTTPHeaders.get_listrccs,|jD]\}}|D]}||fVqq dS)zReturns an iterable of all (name, value) pairs. If a header has multiple values, multiple pairs will be returned with the same name. N)r4items)r.rvaluesr=r r r$r8szHTTPHeaders.get_alllinercCs|drX|jdurtdd|}|j|jd|7<|j|j|7<n@z|dd\}}WntytdYn0||| dS) 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 :r2zno colon in header line) isspacer5HTTPInputErrorlstripr4r3r( ValueErrorr9strip)r.rIZnew_partrr=r r r$ parse_lines    zHTTPHeaders.parse_line)headersrcCs>|}|dD](}|dr*|dd}|r||q|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`.   NrK)r(endswithrR)clsrShrIr r r$parses   zHTTPHeaders.parsecCs"t|}||j|<|g|j|<dSr,r)r3r4r@r r r$ __setitem__s zHTTPHeaders.__setitem__cCs|jt|Sr,)r3r))r.rr r r$ __getitem__szHTTPHeaders.__getitem__cCst|}|j|=|j|=dSr,rZrCr r r$ __delitem__szHTTPHeaders.__delitem__cCs t|jSr,)r6r3r.r r r$__len__szHTTPHeaders.__len__cCs t|jSr,)iterr3r^r r r$__iter__szHTTPHeaders.__iter__cCst|Sr,)r*r^r r r$copyszHTTPHeaders.copycCs2g}|D]\}}|d||fq d|S)Nz%s: %s )r8r?r')r.linesrr=r r r$__str__szHTTPHeaders.__str__)__name__ __module__ __qualname____doc__typingoverloadrstrrr/rAnyr9rDrr8rR classmethodrYr[r\r]intr_rrarb__copy__re __unicode__r r r r$r*Ls2  r*c @seZdZdZdZdZdZdeeeeeee ee eeee ee dfededee dd dd Zee eejjfd d d Zed d dZed ddZdeede e fdddZdd ddZed ddZdS)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``. NHTTP/1.0HTTPFileHTTPConnectionRequestStartLine) methoduriversionrSbodyhostfiles connection start_lineserver_connectionrc Cs| dur| \}}}||_||_||_|p,t|_|p6d|_t|dd} t| dd|_t| dd|_|pt|j dptd|_ t |j d|_ |pi|_||_| |_t|_d|_|dur|d \|_} |_t|jd d |_t|j|_i|_dS) Nr&context remote_ipprotocolhttpHostz 127.0.0.1r?Tkeep_blank_values)rwrxryr*rSrzgetattrrrrBr{split_host_and_portlowerZ host_namer|r}rtime _start_time _finish_time partitionpathqueryr argumentsrbdeepcopyZquery_argumentsbody_arguments) r.rwrxryrSrzr{r|r}r~rrsepr r r$r/Zs,       zHTTPServerRequest.__init__rEc Cst|dsztj|_d|jvrzzt|jd}WntyDYn60|D]*\}}z||j|<WqNtyvYqN0qN|jS)z0A dictionary of ``http.cookies.Morsel`` objects._cookiesCookie) hasattrrcookies SimpleCookierrS parse_cookie ExceptionrF)r.parsedr;r<r r r$rs    zHTTPServerRequest.cookiescCs|jd|j|jS)z+Reconstructs the full URL for this request.z://)rr{rxr^r r r$full_urlszHTTPServerRequest.full_urlcCs(|jdurt|jS|j|jSdS)z?Returns the amount of time it took for this request to execute.N)rrrr^r r r$ request_times zHTTPServerRequest.request_timeF) binary_formrcCs>z$|jdurWdS|jjjj|dWSty8YdS0dS)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)r}streamsocket getpeercertr)r.rr r r$get_ssl_certificates   z%HTTPServerRequest.get_ssl_certificatecCsNt|jdd|j|j|j|j|jD]\}}|j|g |q,dS)N Content-Typerc) parse_body_argumentsrSrBrzrr|rFr setdefaultextend)r.r;r<r r r$ _parse_bodys zHTTPServerRequest._parse_bodycs,d}dfdd|D}djj|fS)N)rr{rwrxryrz, csg|]}d|t|fqS)z%s=%r)r)r"nr^r r$r%r&z.HTTPServerRequest.__repr__..z%s(%s))r' __class__rf)r.attrsr0r r^r$__repr__szHTTPServerRequest.__repr__) NNrsNNNNNNN)F)rfrgrhrirrZ _body_futurerrlr*bytesrrobjectr/propertyrrMorselrfloatrboolrrrrr r r r$rrsL\ (  rrc@seZdZdZdS)rNzqException class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0 Nrfrgrhrir r r r$rNsrNc@seZdZdZdS)HTTPOutputErrorzJException class for errors in HTTP output. .. versionadded:: 4.0 Nrr r r r$rsrc@s2eZdZdZedddddZeddd d ZdS) HTTPServerConnectionDelegatez_Implement this interface to handle requests from `.HTTPServer`. .. versionadded:: 4.0 ruHTTPMessageDelegate) server_conn request_connrcCs tdS)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`. NNotImplementedError)r.rrr r r$ start_requests z*HTTPServerConnectionDelegate.start_requestN)rrcCsdS)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.rr r r$on_closesz%HTTPServerConnectionDelegate.on_close)rfrgrhrirrrr r r r$rs  rc@sbeZdZdZedeeeddddZe eedddd Z dd d d Z dd d dZ dS)rz_Implement this interface to handle an HTTP request or response. .. versionadded:: 4.0 rvResponseStartLineN)r~rSrcCsdS)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.r~rSr r r$headers_received sz$HTTPMessageDelegate.headers_receivedchunkrcCsdS)ziCalled when a chunk of data has been received. May return a `.Future` for flow control. Nr r.rr r r$ data_receivedsz!HTTPMessageDelegate.data_receivedrEcCsdS)z6Called after the last chunk of data has been received.Nr r^r r r$finish&szHTTPMessageDelegate.finishcCsdS)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 r^r r r$on_connection_close*sz'HTTPMessageDelegate.on_connection_close) rfrgrhrirr*rrrrrrrr r r r$rs rc@sLeZdZdZdedeeeddddZeddd d Z dd d d Z dS)ruzYApplications use this interface to write their responses. .. versionadded:: 4.0 Nrz Future[None])r~rSrrcCs tdS)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. Nr)r.r~rSrr r r$ write_headers9szHTTPConnection.write_headersrcCs tdS)zWrites a chunk of body data. Returns a future for flow control. .. versionchanged:: 6.0 The ``callback`` argument was removed. Nrrr r r$writeQs zHTTPConnection.writerEcCs tdS)z3Indicates that the last body data has been written.Nrr^r r r$r\szHTTPConnection.finish)N) rfrgrhrirr*rrrrrr r r r$ru3s   ru.)urlr0rcCs|dur |St|}t|tr>> 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' NTrz7'args' parameter should be dict, list or tuple. Not {0}rr2)rr7dictrrrrFlisttupleformattype TypeErrorrr)rr0 parsed_urlZ parsed_queryerrZ final_queryr r r$ url_concatas0   rc@s*eZdZUdZeed<eed<eed<dS)rtzRepresents a file uploaded via a form. For backwards compatibility, its instance attributes are also accessible as dictionary keys. * ``filename`` * ``body`` * ``content_type`` filenamerz content_typeN)rfrgrhrirl__annotations__rr r r r$rts  rt) range_headerrcCs|d\}}}||}}|dkr.dS|d\}}}zt|}t|}WntyfYdS0|dur|dur|dkr| }d}n|d7}||fS)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 =rNrrr2)rrQ _int_or_nonerP)runit_r=Zstart_bZend_bstartendr r r$_parse_request_ranges"  r)rrtotalrcCs"|pd}|p|d}d|||fS)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 rr2zbytes %s-%s/%sr )rrrr r r$_get_content_ranges  r)valrcCs|}|dkrdSt|S)Nrc)rQro)rr r r$rsr)rrzrr|rSrc CsV|dr|r*d|vr*td|ddSzt|dd}Wn4tyn}ztd|i}WYd}~n d}~00|D]\}}|rx||g|qxn|drR|rd|vrtd|ddSzX|d } | D]<} | d \} } } | d kr| rt t | |||qqt d Wn2tyP}ztd |WYd}~n d}~00dS)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 rrFrrr(rQrparse_multipart_form_datar rP)rrzrr|rSZ uri_argumentserrGfieldsfieldr;rr<r r r$rs<        r)rdatarr|rcCs^|dr |dr |dd}|d|d}|dkrHtddS|d|d|d}|D]}|spqf|d}|dkrtd qft|d| d }| d d } t | \} } | d ks|dstdqf||dd} | dstdqf| d} | drF| dd}| | g t| d| |dqf| | g | qfdS)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. "r2rKs--z.Invalid multipart/form-data: no final boundaryNs s z#multipart/form-data missing headerszutf-8zContent-Dispositionrcz form-datazInvalid multipart/form-datarz&multipart/form-data value missing namerrzapplication/unknown)rrzr)rrVrfindr rr(findr*rYdecoderB _parse_headerrr?rt)rrrr|Zfinal_boundary_indexpartspartZeohrSZ disp_header dispositionZ disp_paramsr=rctyper r r$rsB             r)tsrcCsht|ttfr|}nDt|ttjfr0t|}n(t|tjrLt| }n t d|t j j |ddS)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)r7rorrr struct_timecalendartimegmdatetime utctimetupleremailutils formatdate)rZtime_numr r r$format_timestampTs    rrv)rwrryz^HTTP/1\.[0-9]$rHcCsRz|d\}}}Wnty.tdYn0t|sFtd|t|||S)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') rJzMalformed HTTP request linez/Malformed HTTP version in HTTP Request-Line: %r)r(rPrN_http_version_rematchrv)rIrwrryr r r$parse_request_start_linets  rr)rycodereasonz (HTTP/1.[0-9]) ([0-9]+) ([^\r]*)cCs@t|}t|}|stdt|dt|d|dS)zReturns a (version, code, reason) tuple for an HTTP 1.x response line. The response is a `collections.namedtuple`. >>> parse_response_start_line("HTTP/1.1 200 OK") ResponseStartLine(version='HTTP/1.1', code=200, reason='OK') z!Error parsing response start liner2rr)r _http_response_line_rerrNrgroupro)rIrr r r$parse_response_start_lines  r )srccs|dddkr|dd}|d}|dkr`|dd||dd|dr`|d|d}q&|dkrpt|}|d|}|V||d}qdS)Nr2rr"z\"r)rcountr6rQ)r rfr r r$ _parseparams  (  rc Cstd|}t|}dg}|D]P}|d}|dkr|d|}||dd}||t|fqtj |}| di} |D]L\}} tj | }t |dkr|ddkr|d dkr|dd }|| |<q|| 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)ZDummyr=rrNr2rr rK) rnextrrQrr?r rr decode_paramspopcollapse_rfc2231_valuer6) rIrkeyparamspirr=Zdecoded_paramspdictZ decoded_valuer r r$rs$      $  r)rrrcCsT|s|S|g}t|D].\}}|dur6||q|d||fqd|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' Nz%s=%sz; )sortedrFr?r')rroutr;r<r r r$_encode_headers r)usernamepasswordrcCs@t|trtd|}t|tr,td|}t|dt|S)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:)r7r unicodedata normalizer )rrr r r$encode_username_passwords    r!cCsddl}|S)Nr)doctestZ DocTestSuite)r"r r r$doctestssr#z ^(.+):(\d+)$)netlocrcCs8t|}|r(|d}t|d}n|}d}||fS)zReturns ``(host, port)`` tuple from ``netloc``. Returned ``port`` will be ``None`` if not present. .. versionadded:: 4.1 r2rN) _netloc_rerrro)r$rr{portr r r$rs  r)qsrccs*|D]\}}|D]}||fVqqdS)zgGenerator converting a result of ``parse_qs`` back to name-value pairs. .. versionadded:: 5.0 N)rF)r'r;vsr<r r r$ qs_to_qslsr)z\\[0-3][0-7][0-7]z[\\].rccCsN|dust|dkr|S|ddks0|ddkr4|S|dd}d}t|}g}d|krf|krFnnt||}t||}|s|s|||dqFd}}|r|d}|r|d}|r|r||kr|||||||d|d}qP|||||tt||d|dd|d}qPt|S) zHandle double quotes and escaping in cookie values. This method is copied verbatim from the Python 3.5 standard library (http.cookies._unquote) so we don't have to depend on non-public interfaces. Nrrr rKr2r) r6 _OctalPattsearch _QuotePattr?rchrro _nulljoin)r rrreso_matchq_matchjr;r r r$_unquote_cookie&s6       $ r4)cookiercCsri}|tdD]Z}td|vr8|tdd\}}ntd|}}||}}|s`|rt|||<q|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 rrr2rc)r(rlrQr4)r5Z cookiedictrrrr r r$rXs  r)N)brircollections.abc collectionsrbr email.utilsr functoolsr http.clientr http.cookiesrresslrrr urllib.parserrrrZtornado.escaper r r Z tornado.logr Z tornado.utilr rrjrrrrrrrrrrr TYPE_CHECKINGrZasynciorZunittestrlr)abcMutableMappingr*rrrrrNrrrrurrtrorrrrrrrrrr namedtuplervcompilerrrrr rrrr!r#r%rr)r+r-r'r/r4rr r r r$s    4   ,_  ./. / 3  2 ;    #  (  2