U lu f @sBdZddlZddlZddlZddlZddlZddlm 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-ZDdae2eEe'e2e$eEfe'e2e$e@fe)e6dd.d/d0ZFeEeEe'e2e$eEfe'e2e$e@fdd1d2d3ZGe(eAeHeIejJejfe2d4d5d6ZKeLd7d8d9d:gZMeNd;ZOe2eMd<d=d>ZPeLd?d:d@dAgZQeNdBZRe2eQd<dCdDZSe2e+e2ddfdEdFdGZTe2e"e2e'e2e2ffd<dHdIZUe2e'e2e2fe2dJdKdLZVe(e2eEfe(e2eEfeEdMdNdOZWdPdQZXeNdRZYe2e"e2e)eAfdSdTdUZZe'e2e$e,fe#e"e2e,fdVdWdXZ[eNdYZ\eNdZZ]d[j^Z_e2e2dEd\d]Z`e2e'e2e2fd^d_d`ZadS)bzHTTP 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 4/tmp/pip-unpacked-wheel-bmg6zs32/tornado/httputil.py Isz%_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-r/r r r$r.qs)kwargsrcKsdSr+r )r-r0r r r$r.us)r/r0rcOsli|_i|_d|_t|dkr\t|dkr\t|dtr\|dD]\}}|||qDn |j||dS)Nr) _dict_as_list _last_keylen isinstancer)get_alladdupdate)r-r/r0kvr r r$r.ys&)rvaluercCsRt|}||_||krFt||dt||j|<|j||n|||<dS)z#Adds a new value for the given key.,N)r(r4r r2r3appendr-rr< norm_namer r r$r8szHTTPHeaders.addrcCst|}|j|gS)z2Returns all values for the given header as a list.)r(r3getr-rr@r 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)r3items)r-rvaluesr<r r r$r7szHTTPHeaders.get_alllinercCs|drX|jdkrtdd|}|j|jd|7<|j|j|7<nBz|dd\}}Wntk rtdYnX||| 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 :r1zno colon in header line) isspacer4HTTPInputErrorlstripr3r2r' ValueErrorr8strip)r-rHZnew_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`.   NrJ)r'endswithrQ)clsrRhrHr r r$parses   zHTTPHeaders.parsecCs"t|}||j|<|g|j|<dSr+r(r2r3r?r r r$ __setitem__s zHTTPHeaders.__setitem__cCs|jt|Sr+)r2r()r-rr r r$ __getitem__szHTTPHeaders.__getitem__cCst|}|j|=|j|=dSr+rYrBr r r$ __delitem__szHTTPHeaders.__delitem__cCs t|jSr+)r5r2r-r r r$__len__szHTTPHeaders.__len__cCs t|jSr+)iterr2r]r r r$__iter__szHTTPHeaders.__iter__cCst|Sr+)r)r]r r r$copyszHTTPHeaders.copycCs2g}|D]\}}|d||fq d|S)Nz%s: %s )r7r>r&)r-linesrr<r r r$__str__szHTTPHeaders.__str__)__name__ __module__ __qualname____doc__typingoverloadrstrrr.rAnyr8rCrr7rQ classmethodrXrZr[r\intr^rr`ra__copy__rd __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) methoduriversionrRbodyhostfiles connection start_lineserver_connectionrc Cs| dk r| \}}}||_||_||_|p,t|_|p6d|_t|dd} t| dd|_t| dd|_|pt|j dptd|_ t |j d|_ |pi|_||_| |_t|_d|_|dk r|d \|_} |_t|jd d |_t|j|_i|_dS) Ncontext remote_ipprotocolhttpHostz 127.0.0.1r?Tkeep_blank_values)rvrwrxr)rRrygetattrrrrArzsplit_host_and_portlowerZ host_namer{r|r~time _start_time _finish_time partitionpathqueryr argumentsradeepcopyZquery_argumentsbody_arguments) r-rvrwrxrRryrzr{r|r}r~rsepr r r$r.Zs,       zHTTPServerRequest.__init__rDc Cst|ds~tj|_d|jkr~zt|jd}Wntk rFYn8X|D],\}}z||j|<WqPtk rzYqPXqP|jS)z0A dictionary of ``http.cookies.Morsel`` objects._cookiesCookie) hasattrrcookies SimpleCookierrR parse_cookie ExceptionrE)r-parsedr:r;r r r$rs  zHTTPServerRequest.cookiescCs|jd|j|jS)z+Reconstructs the full URL for this request.z://)rrzrwr]r r r$full_urlszHTTPServerRequest.full_urlcCs(|jdkrt|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$|jdkrWdS|jjjj|dWStk r:YdSXdS)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-Typerb) parse_body_argumentsrRrAryrr{rEr setdefaultextend)r-r:r;r r r$ _parse_bodys zHTTPServerRequest._parse_bodycs,d}dfdd|D}djj|fS)N)rrzrvrwrxrz, csg|]}d|t|fqS)z%s=%r)r)r"nr]r r$r%sz.HTTPServerRequest.__repr__..z%s(%s))r& __class__re)r-attrsr/r r]r$__repr__szHTTPServerRequest.__repr__) NNrrNNNNNNN)F)rerfrgrhrrZ _body_futurerrkr)bytesrrobjectr.propertyrrMorselrfloatrboolrrrrr r r r$rqsL\ (  rqc@seZdZdZdS)rMzqException class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0 Nrerfrgrhr r r r$rMsrMc@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 rtHTTPMessageDelegate) 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)rerfrgrhrrrr 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 ruResponseStartLineN)r}rRrcCsdS)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}rRr 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_receivedrDcCsdS)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) rerfrgrhrr)rrrrrrrr r r r$rs rc@sLeZdZdZdedeeeddddZeddd d Z dd d d Z dS)rtzYApplications use this interface to write their responses. .. versionadded:: 4.0 Nrz Future[None])r}rRrrcCs 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}rRrr 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.writerDcCs tdS)z3Indicates that the last body data has been written.Nrr]r r r$r\szHTTPConnection.finish)N) rerfrgrhrr)rrrrrr r r r$rt3s   rt.)urlr/rcCs|dkr |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}rr1)rr6dictrrrrElisttupleformattype TypeErrorrr)rr/ parsed_urlZ parsed_queryerrZ final_queryr r r$ url_concatas0   rc@s*eZdZUdZeed<eed<eed<dS)rszRepresents a file uploaded via a form. For backwards compatibility, its instance attributes are also accessible as dictionary keys. * ``filename`` * ``body`` * ``content_type`` filenamery content_typeN)rerfrgrhrk__annotations__rr r r r$rss  rs) range_headerrcCs|d\}}}||}}|dkr.dS|d\}}}zt|}t|}Wntk rhYdSX|dk r|dkr|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 =rNrrr1)rrP _int_or_nonerO)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 rr1zbytes %s-%s/%sr )rrrr r r$_get_content_ranges  r)valrcCs|}|dkrdSt|S)Nrb)rPrn)rr r r$rsr)rryrr{rRrc CsR|dr|r*d|kr*td|ddSzt|dd}Wn2tk rl}ztd|i}W5d}~XYnX|D]\}}|rv||g|qvn|drN|rd|krtd|ddSzX|d } | D]<} | d \} } } | d kr| rt t | |||qqt d Wn0tk rL}ztd |W5d}~XYnXdS)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 rrErrr'rPrparse_multipart_form_datar rO)rryrr{rRZ uri_argumentserrFfieldsfieldr: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. "r1rJs--z.Invalid multipart/form-data: no final boundaryNs s z#multipart/form-data missing headerszutf-8zContent-Dispositionrbz form-datazInvalid multipart/form-datarz&multipart/form-data value missing namerrzapplication/unknown)rryr)rrUrfindr rr'findr)rXdecoderA _parse_headerrr>rs)rrrr{Zfinal_boundary_indexpartspartZeohrRZ disp_header dispositionZ disp_paramsr<rctyper r r$rsF            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)r6rnrrr struct_timecalendartimegmdatetime utctimetupleremailutils formatdate)rZtime_numr r r$format_timestampTs    rrurvrrxz^HTTP/1\.[0-9]$rGcCsTz|d\}}}Wntk r0tdYnXt|sHtd|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') rIzMalformed HTTP request linez/Malformed HTTP version in HTTP Request-Line: %r)r'rOrM_http_version_rematchru)rHrvrrxr r r$parse_request_start_linets rrcodereasonz (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 liner1rr)r _http_response_line_rerrMrgrouprn)rHrr r r$parse_response_start_lines  r )srccs|dddkr|dd}|d}|dkr`|dd||dd|dr`|d|d}q&|dkrpt|}|d|}|V||d}qdS)Nr1rr"z\"r)rcountr5rP)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<rrNr1rr rJ) rnextrrPrr>r rr decode_paramspopcollapse_rfc2231_valuer5) rHrkeyparamspirr<Zdecoded_paramspdictZ decoded_valuer r r$rs$      $  r)rrrcCsT|s|S|g}t|D].\}}|dkr6||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; )sortedrEr>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:)r6r 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 r1rN) _netloc_rerrrn)r$rrzportr r r$rs  r)qsrccs*|D]\}}|D]}||fVqqdS)zgGenerator converting a result of ``parse_qs`` back to name-value pairs. .. versionadded:: 5.0 N)rE)r'r:vsr;r r r$ qs_to_qslsr)z\\[0-3][0-7][0-7]z[\\].rbcCsN|dkst|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 rJr1r) r5 _OctalPattsearch _QuotePattr>rchrrn _nulljoin)r rrreso_matchq_matchjr:r r r$_unquote_cookie&s6       $ r4)cookiercCsri}|tdD]Z}td|kr8|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 rrr1rb)r'rkrPr4)r5Z cookiedictrrrr r r$rXs  r)N)brhrcollections.abc collectionsrar email.utilsr functoolsr http.clientr http.cookiesrresslrrr urllib.parserrrrZtornado.escaper r r Z tornado.logr Z tornado.utilr rrirrrrrrrrrrr TYPE_CHECKINGrZasynciorZunittestrkr(abcMutableMappingr)rrqrrMrrrrtrrsrnrrrrrrrrrr namedtuplerucompilerrrrr rrrr!r#r%rr)r+r-r&r/r4rr r r r$s    4   ,_  ./. / 3  2 ;    #   (  2