B h @sdZddlZddlZddlZddlZddlZddlmZddl Z ddl Z ddl m Z ddlZddlZddlmZmZmZmZddlmZmZmZddlmZddlmZmZeddlZdd lmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ej*rdd lm+Z+dd l,m-Z-ddl.Z.e /d Z0Gd dde1Z2e2dZ3Gdddej4j5Z6Gddde7Z8Gddde9Z:Gddde9Z;Gddde7Ze?e%de$e?e?fe!ee?e?feee?e?fdffe?dd d!Z@Gd"d#d#eZAe?e&ee&eBe&eBfd$d%d&ZCe&eBe&eBeBe?d'd(d)ZDe?e&eBd*d+d,ZEd]e?eFe$e?e!eFfe$e?e!eAfe6dd-d.d/ZGeFeFe$e?e!eFfe$e?e!eAfdd0d1d2ZHe%eBeIeJejKejfe?d3d4d5ZLeMd6d7d8d9gZNe?eNd:d;d<ZOeMd=d9d>d?gZPe?ePd:d@dAZQe?e(e?ddfdBdCdDZRe?ee?e$e?e?ffd:dEdFZSe?e$e?e?fe?dGdHdIZTe%e?eFfe%e?eFfeFdJdKdLZUdMdNZVe?ee?e&eBfdOdPdQZWe$e?e!e)fe ee?e)fdRdSdTZXe /dUZYe /dVZZdWj[Z\e?e?dBdXdYZ]e?e$e?e?fdZd[d\Z^dS)^zHTTP utility code shared by clients and servers. This module also defines the `HTTPServerRequest` class which is exposed via `tornado.web.RequestHandler.request`. N) responses)SSLError) urlencodeurlparse urlunparse parse_qsl) native_strparse_qs_bytesutf8)gen_log) ObjectDict unicode_type) TupleIterableListMappingIteratorDictUnionOptional Awaitable GeneratorAnyStr)Deque)Futurez\r?\ncs8eZdZdZeddfdd ZeedddZZS) _NormalizedHeaderCacheaKDynamic cached mapping of header names to Http-Header-Case. Implemented as a dict subclass so that cache hits are as fast as a normal dict lookup, without the overhead of a python function call. >>> normalized_headers = _NormalizedHeaderCache(10) >>> normalized_headers["coNtent-TYPE"] 'Content-Type' N)sizereturncs"tt|||_t|_dS)N)superr__init__r collectionsdequequeue)selfr) __class__MC:\Users\sanjo\AppData\Local\Qlobot\Launcher\ext_packages\tornado\httputil.pyrRsz_NormalizedHeaderCache.__init__)keyrcCsRddd|dD}|||<|j|t|j|jkrN|j}||=|S)N-cSsg|] }|qSr%) capitalize).0wr%r%r& Xsz6_NormalizedHeaderCache.__missing__..)joinsplitr"appendlenrpopleft)r#r'Z normalizedZold_keyr%r%r& __missing__Ws  z"_NormalizedHeaderCache.__missing__) __name__ __module__ __qualname____doc__intrstrr2 __classcell__r%r%)r$r&rFs ric@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__argrcCsdS)Nr%)r#r;r%r%r&rszHTTPHeaders.__init__cCsdS)Nr%)r#r;r%r%r&rs)argsrcGsdS)Nr%)r#r<r%r%r&rs)kwargsrcKsdS)Nr%)r#r=r%r%r&rs)r<r=rcOspi|_i|_d|_t|dkr`t|dkr`t|dtr`x2|dD]\}}|||qFWn |j||dS)Nr) _dict_as_list _last_keyr0 isinstancer:get_alladdupdate)r#r<r=kvr%r%r&rs&)namevaluercCsRt|}||_||krFt||dt||j|<|j||n|||<dS)z#Adds a new value for the given key.,N)_normalized_headersrArr?r@r/)r#rHrI norm_namer%r%r&rDs zHTTPHeaders.add)rHrcCst|}|j|gS)z2Returns all values for the given header as a list.)rKr@get)r#rHrLr%r%r&get_listszHTTPHeaders.get_list)rccs4x.|jD] \}}x|D]}||fVqWq WdS)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#rHvaluesrIr%r%r&rCs zHTTPHeaders.get_all)linercCs|drX|jdkrtdd|}|j|jd|7<|j|j|7<nBy|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 :r>zno colon in header line) isspacerAHTTPInputErrorlstripr@r?r. ValueErrorrDstrip)r#rQZnew_partrHrIr%r%r& parse_lines   zHTTPHeaders.parse_line)headersrcCs,|}x t|D]}|r||qW|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`. )_CRLF_REr.rZ)clsr[hrQr%r%r&parses zHTTPHeaders.parsecCs"t|}||j|<|g|j|<dS)N)rKr?r@)r#rHrIrLr%r%r& __setitem__s zHTTPHeaders.__setitem__cCs|jt|S)N)r?rK)r#rHr%r%r& __getitem__szHTTPHeaders.__getitem__cCst|}|j|=|j|=dS)N)rKr?r@)r#rHrLr%r%r& __delitem__szHTTPHeaders.__delitem__cCs t|jS)N)r0r?)r#r%r%r&__len__szHTTPHeaders.__len__cCs t|jS)N)iterr?)r#r%r%r&__iter__szHTTPHeaders.__iter__cCst|S)N)r:)r#r%r%r&copyszHTTPHeaders.copycCs6g}x&|D]\}}|d||fqWd|S)Nz%s: %s )rCr/r-)r#linesrHrIr%r%r&__str__szHTTPHeaders.__str__)r3r4r5r6typingoverloadrr8rrrAnyrDrNrrCrZ classmethodr_r`rarbr7rcrrerf__copy__ri __unicode__r%r%r%r&r:gs2  r:c @seZdZdZdZdZdZdeeeee ee ee dfdde dd dd Z ee 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) methoduriversionr[bodyhostfiles 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?T)keep_blank_values)rurvrwr:r[rxgetattrrrrMrysplit_host_and_portlowerZ host_namerzr{r}time _start_time _finish_time partitionpathqueryr argumentsrfdeepcopyZquery_argumentsbody_arguments) r#rurvrwr[rxryrzr{r|r}rsepr%r%r&rqs,       zHTTPServerRequest.__init__)rc Cst|dstj|_d|jkryt|jd}Wntk rFYnReturns 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_certificatecCsRt|jdd|j|j|j|jx*|jD]\}}|j|g |q.WdS)Nz Content-Typerg) parse_body_argumentsr[rMrxrrzrOr setdefaultextend)r#rFrGr%r%r& _parse_bodys zHTTPServerRequest._parse_bodycs,d}dfdd|D}djj|fS)N)rryrurvrwrz, csg|]}d|t|fqS)z%s=%r)r)r*n)r#r%r&r,sz.HTTPServerRequest.__repr__..z%s(%s))r-r$r3)r#attrsr<r%)r#r&__repr__szHTTPServerRequest.__repr__) NNrqNNNNNNN)F)r3r4r5r6rrZ _body_futurer8r:bytesrrobjectrpropertyrrMorselrfloatrboolrrrrr%r%r%r&rps.[" rpc@seZdZdZdS)rVzqException class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0 N)r3r4r5r6r%r%r%r&rVsrVc@seZdZdZdS)HTTPOutputErrorzJException class for errors in HTTP output. .. versionadded:: 4.0 N)r3r4r5r6r%r%r%r&rsrc@s2eZdZdZedddddZeddd d ZdS) HTTPServerConnectionDelegatez_Implement this interface to handle requests from `.HTTPServer`. .. versionadded:: 4.0 rsHTTPMessageDelegate) 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`. N)NotImplementedError)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)r3r4r5r6rrrr%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 )rtResponseStartLineN)r|r[rcCsdS)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|r[r%r%r&headers_received!sz$HTTPMessageDelegate.headers_received)chunkrcCsdS)ziCalled when a chunk of data has been received. May return a `.Future` for flow control. Nr%)r#rr%r%r& data_received4sz!HTTPMessageDelegate.data_received)rcCsdS)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) r3r4r5r6rr:rrrrrrrr%r%r%r&rsrc@sHeZdZdZdedeeddddZeddd d Zdd d d Z dS)rszYApplications use this interface to write their responses. .. versionadded:: 4.0 N)rtrz Future[None])r|r[rrcCs 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. N)r)r#r|r[rr%r%r& write_headersNszHTTPConnection.write_headers)rrcCs tdS)zWrites a chunk of body data. Returns a future for flow control. .. versionchanged:: 6.0 The ``callback`` argument was removed. N)r)r#rr%r%r&writefs zHTTPConnection.write)rcCs tdS)z>> 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' NT)rz7'args' parameter should be dict, list or tuple. Not {0}rr>)rrBdictrrrrOlisttupleformattype TypeErrorrr)rr< parsed_urlZ parsed_queryerrZ final_queryr%r%r& url_concatws*    rc@seZdZdZdS)rrzRepresents a file uploaded via a form. For backwards compatibility, its instance attributes are also accessible as dictionary keys. * ``filename`` * ``body`` * ``content_type`` N)r3r4r5r6r%r%r%r&rrs rr) range_headerrcCs|d\}}}||}}|dkr.dS|d\}}}yt|}t|}Wntk rfdSX|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 =rNr(rr>)rrY _int_or_nonerX)rZunit_rIZstart_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 rr>zbytes %s-%s/%sr%)rrrr%r%r&_get_content_ranges  r)valrcCs|}|dkrdSt|S)Nrg)rYr7)rr%r%r&rsr) content_typerxrrzr[rc CsZ|dr|r*d|kr*td|ddSytt|dd}Wn2tk rp}ztd|i}Wdd}~XYnXx|D]\}}|r|||g|q|Wn|drV|rd|krtd|ddSyX| d } xH| D]8} | d \} } } | d kr| rt t | |||PqWtd Wn0tk rT}ztd |Wdd}~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: %sNT)rz&Invalid x-www-form-urlencoded body: %szmultipart/form-data;rboundaryzmultipart boundary not foundzInvalid multipart/form-data: %s) startswithr warningr rrrOrrr.rYrparse_multipart_form_datar rX)rrxrrzr[Z uri_argumentserHrPfieldsfieldrFrrGr%r%r&rs8           r)rdatarrzrcCsb|dr |dr |dd}|d|d}|dkrHtddS|d|d|d}x|D]}|srqh|d}|dkrtd qht|d| d }| d d } t | \} } | d ks|dstdqh||dd} | dstdqh| d} | drH| dd}| | g t| d| |dqh| | g | qhWdS)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. "r>rSs--z.Invalid multipart/form-data: no final boundaryNs s z#multipart/form-data missing headerszutf-8zContent-Dispositionrgz form-datazInvalid multipart/form-datarHz&multipart/form-data value missing namefilenamez Content-Typezapplication/unknown)rrxr)rendswithrfindr rr.findr:r_decoderM _parse_headerrr/rr)rrrrzZfinal_boundary_indexpartspartZeohr[Z disp_headerZ dispositionZ disp_paramsrIrHctyper%r%r&r-s>             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. >>> format_timestamp(1359312200) 'Sun, 27 Jan 2013 18:43:20 GMT' zunknown timestamp type: %rT)usegmt)rBr7rrr struct_timecalendartimegmdatetime utctimetupleremailutils formatdate)rZtime_numr%r%r&format_timestampgs    rrtrurrw)rQrcCsVy|d\}}}Wntk r0tdYnXtd|sJtd|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') rRzMalformed HTTP request linez^HTTP/1\.[0-9]$z/Malformed HTTP version in HTTP Request-Line: %r)r.rXrVrematchrt)rQrurrwr%r%r&parse_request_start_lines  rrcodereasoncCsBt|}td|}|s tdt|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(HTTP/1.[0-9]) ([0-9]+) ([^ ]*)z!Error parsing response start liner>rr)rrrrVrgroupr7)rQrr%r%r&parse_response_start_lines  r)srccsx|dddkr|dd}|d}x<|dkrd|dd||dd|drd|d|d}q*W|dkrvt|}|d|}|V||d}qWdS)Nr>rr"z\"r)rcountr0rY)rrfr%r%r& _parseparams  *  rc Cstd|}t|}dg}xX|D]P}|d}|dkr |d|}||dd}||t|fq Wtj |}| di} xT|D]L\}} tj | }t |dkr|ddkr|d dkr|dd }|| |<qW|| 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)ZDummyrIrrNr>rrrS) rnextrrYrr/rrr decode_paramspopcollapse_rfc2231_valuer0) rQrr'paramspirHrIZdecoded_paramspdictZ decoded_valuer%r%r&rs$      $  r)r'r rcCsX|s|S|g}x>t|D].\}}|dkr8||q|d||fqWd|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; )sortedrOr/r-)r'r outrFrGr%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:)rBr unicodedata normalizer )rrr%r%r&encode_username_passwords    rcCsddl}|S)Nr)doctest DocTestSuite)rr%r%r&doctestssr)netlocrcCs:td|}|r*|d}t|d}n|}d}||fS)zReturns ``(host, port)`` tuple from ``netloc``. Returned ``port`` will be ``None`` if not present. .. versionadded:: 4.1 z ^(.+):(\d+)$r>rN)rrrr7)rrryportr%r%r&rs  r)qsrccs2x,|D] \}}x|D]}||fVqWq WdS)zgGenerator converting a result of ``parse_qs`` back to name-value pairs. .. versionadded:: 5.0 N)rO)rrFvsrGr%r%r& qs_to_qsl s rz\\[0-3][0-7][0-7]z[\\].rgcCsP|dkst|dkr|S|ddks0|ddkr4|S|dd}d}t|}g}xd|krh|krFnnt||}t||}|s|s|||dPd}}|r|d}|r|d}|r|r||kr|||||||d|d}qR|||||tt||d|dd|d}qRWt|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. NrrrrSr>r) r0 _OctalPattsearch _QuotePattr/rchrr7 _nulljoin)rr rreso_matchq_matchjrFr%r%r&_unquote_cookie/s6       $ r')cookiercCsvi}xl|tdD]Z}td|kr:|tdd\}}ntd|}}||}}|sb|rt|||<qW|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 rrr>rg)r.r8rYr')r(Z cookiedictrr'rr%r%r&ras  r)N)_r6rr rfr email.utilsr http.clientr http.cookiesrrsslrrr urllib.parserrrrtornado.escaperr r tornado.logr tornado.utilr r rjrrrrrrrrrrr TYPE_CHECKINGrasynciorZunittestcompiler\rrrKabcMutableMappingr:rrprrVrrrrsr8rrrr7rrrrrrrrrr namedtuplertrrrrrr rrrrrr r-r"r'rr%r%r%r&s   4   (]  .00*"1 $+6 #(  2