o [h@sddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZmZmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*dd l+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1dd lm2Z2dd l m3Z3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddlmZ>gdZ?eeee@egeffZAeejBeeCfZDGddde>ZEGdddZFGdddZGeGZH d&d'd!d"ZId(d$d%ZJdS))) annotationsN) TracebackType) Any AwaitableCallable GeneratorListOptionalSequenceSetTupleTypeUnioncast)State)Headers HeadersLikeMultipleValuesError)AbortHandshakeInvalidHandshake InvalidHeaderInvalidMessage InvalidOriginInvalidUpgradeNegotiationError) ExtensionServerExtensionFactory) enable_server_permessage_deflate)build_extensionparse_extensionparse_subprotocolvalidate_subprotocols) USER_AGENT)ExtensionHeader LoggerLikeOrigin Subprotocol)loop_if_py_lt_38)build_response check_request) read_request)WebSocketCommonProtocol)serve unix_serveWebSocketServerProtocolWebSocketServercseZdZdZdZdZdddddddddGfddZdHfd d! ZdId"d#ZdJd%d&Z dKdLd-d.Z dMd3d4Z e dKdNd6d7Z e dOd:d;ZdPd>d?ZdQdCdDZ    dRdSdEdFZZS)Tr0ag WebSocket server connection. :class:`WebSocketServerProtocol` provides :meth:`recv` and :meth:`send` coroutines for receiving and sending messages. It supports asynchronous iteration to receive messages:: async for message in websocket: await process(message) The iterator exits normally when the connection is closed with close code 1000 (OK) or 1001 (going away). It raises a :exc:`~websockets.exceptions.ConnectionClosedError` when the connection is closed with any other code. You may customize the opening handshake in a subclass by overriding :meth:`process_request` or :meth:`select_subprotocol`. Args: ws_server: WebSocket server that created this connection. See :func:`serve` for the documentation of ``ws_handler``, ``logger``, ``origins``, ``extensions``, ``subprotocols``, and ``extra_headers``. See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``, ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``. FserverN)loggerorigins extensions subprotocols extra_headersprocess_requestselect_subprotocol ws_handlertUnion[Callable[[WebSocketServerProtocol], Awaitable[Any]], Callable[[WebSocketServerProtocol, str], Awaitable[Any]]] ws_serverr1r3Optional[LoggerLike]r4$Optional[Sequence[Optional[Origin]]]r5*Optional[Sequence[ServerExtensionFactory]]r6Optional[Sequence[Subprotocol]]r7Optional[HeadersLikeOrCallable]r8EOptional[Callable[[str, Headers], Awaitable[Optional[HTTPResponse]]]]r9OOptional[Callable[[Sequence[Subprotocol], Sequence[Subprotocol]], Subprotocol]]kwargsrreturnNonec  s|dur td}tjdd|i| |dur)d|vr)tdtdd|D}t||_||_ ||_ ||_ ||_ ||_ ||_| |_dS)Nwebsockets.serverr3z!use None instead of '' in originscSsg|] }|dkr dn|qS)rHN).0originrIrI/home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/websockets/legacy/server.py |sz4WebSocketServerProtocol.__init__..rI)logging getLoggersuper__init__warningswarnDeprecationWarningremove_path_argumentr:r<r4available_extensionsavailable_subprotocolsr7_process_request_select_subprotocol) selfr:r<r3r4r5r6r7r8r9rD __class__rIrLrQas    z WebSocketServerProtocol.__init__ transportasyncio.BaseTransportcs.t||j||j||_dS)zJ Register connection and initialize a task to handle it. N)rPconnection_mader<registerloop create_taskhandler handler_task)rZr]r[rIrLr_s  z'WebSocketServerProtocol.connection_madec sJzzYz|j|j|j|j|jdIdHWntjy ty'ty}zt |t r@|j |j |j }}}n{t |trb|jrP|jjdddtjjtd|d}}}nYt |tr|jrr|jjdddtjjtd gd|d }}}n5t |tr|jr|jjd ddtjjtd|d}}}n|jjd ddtjjtd }}}|dtjjdd|dt |dt!t"||dd|dd|#||||j$d|j%|j&|'IdHWYd}~WW|j()||j$ddSd}~wwz |*|IdHWnty8|jjddd|j+s7|,dwz |-IdHWntyKty[|jjdddwWntyyz|j.-Wn tyvYnwYnwW|j()||j$ddSW|j()||j$ddS|j()||j$dw)z Handle the lifecycle of a WebSocket connection. Since this method doesn't have a caller able to handle exceptions, it attemps to log relevant ones and guarantees that the TCP connection is closed before exiting. )r4rVrWr7Nz! invalid originT)exc_infoz'Failed to open a WebSocket connection: z. z! invalid upgrade)ZUpgrade websocketz^. You cannot access a WebSocket server directly with a browser. You need a WebSocket client. z! invalid handshakezopening handshake failedsLFailed to open a WebSocket connection. See server log for more information. DateusegmtServerzContent-Lengthz Content-Typez text/plain Connectionclosezconnection failed (%d %s)zconnection closedzconnection handler failedizclosing handshake failed)/ handshaker4rVrWr7asyncioCancelledErrorConnectionError Exception isinstancerstatusheadersbodyrdebugr3http HTTPStatus FORBIDDENrencoderUPGRADE_REQUIREDr BAD_REQUESTerrorINTERNAL_SERVER_ERROR setdefaultemailutils formatdater#strlenwrite_http_responseinfovaluephraseZclose_transportr< unregisterr:closedZfail_connectionrlr])rZexcrsrtrurIrIrLrcs              8    zWebSocketServerProtocol.handlerTuple[str, Headers]c sz t|jIdH\}}Wntjyty&}ztd|d}~ww|jrB|jd||D] \}}|jd||q5||_ ||_ ||fS)a: Read request line and headers from the HTTP request. If the request contains a body, it may be read from ``self.reader`` after this coroutine returns. Raises: InvalidMessage: if the HTTP message is malformed or isn't an HTTP/1.1 GET request. Nz$did not receive a valid HTTP requestz< GET %s HTTP/1.1z< %s: %s) r,readerrnrorqrrvr3 raw_itemspathrequest_headers)rZrrtrkeyrrIrIrLread_http_requests   z)WebSocketServerProtocol.read_http_requestrshttp.HTTPStatusrtrruOptional[bytes]cCs||_|jr.|jd|j|j|D] \}}|jd||q|dur.|jdt|d|jd|jd}|t|7}|j | |durS|j |dSdS)z Write status line and headers to the HTTP response. This coroutine is also able to write a response body. z> HTTP/1.1 %d %sz> %s: %sNz> [body] (%d bytes)z HTTP/1.1  z ) response_headersrvr3rrrrrr]writerz)rZrsrtrurrresponserIrIrLr"s  z+WebSocketServerProtocol.write_http_responserrrOptional[HTTPResponse]cs@|jdur|||}t|tr|IdHStdt|SdS)a Intercept the HTTP request and return an HTTP response if appropriate. You may override this method in a :class:`WebSocketServerProtocol` subclass, for example: * to return a HTTP 200 OK response on a given path; then a load balancer can use this path for a health check; * to authenticate the request and return a HTTP 401 Unauthorized or a HTTP 403 Forbidden when authentication fails. You may also override this method with the ``process_request`` argument of :func:`serve` and :class:`WebSocketServerProtocol`. This is equivalent, except ``process_request`` won't have access to the protocol instance, so it can't store information for later use. :meth:`process_request` is expected to complete quickly. If it may run for a long time, then it should await :meth:`wait_closed` and exit if :meth:`wait_closed` completes, or else it could prevent the server from shutting down. Args: path: request path, including optional query string. request_headers: request headers. Returns: Optional[Tuple[http.HTTPStatus, HeadersLike, bytes]]: :obj:`None` to continue the WebSocket handshake normally. An HTTP response, represented by a 3-uple of the response status, headers, and body, to abort the WebSocket handshake and return that HTTP response instead. N&declare process_request as a coroutine)rXrrrrRrSrT)rZrrrrIrIrLr8>s %   z'WebSocketServerProtocol.process_requestOptional[Origin]c CsZz ttt|d}Wnty}ztdd|d}~ww|dur+||vr+t||S)z Handle the Origin HTTP request header. Args: headers: request headers. origins: optional list of acceptable origins. Raises: InvalidOrigin: if the origin isn't acceptable. r&z!more than one Origin header foundN)rr r&getrrr)rtr4rKrrIrIrLprocess_originos z&WebSocketServerProtocol.process_originrV%Tuple[Optional[str], List[Extension]]c Csd}g}g}|d}|rK|rKtdd|Dg}|D]/\}}|D](} | j|kr)q!z | ||\} } Wn ty<Yq!w||| f|| q|rQt|}||fS)a Handle the Sec-WebSocket-Extensions HTTP request header. Accept or reject each extension proposed in the client request. Negotiate parameters for accepted extensions. Return the Sec-WebSocket-Extensions HTTP response header and the list of accepted extensions. :rfc:`6455` leaves the rules up to the specification of each :extension. To provide this level of flexibility, for each extension proposed by the client, we check for a match with each extension available in the server configuration. If no match is found, the extension is ignored. If several variants of the same extension are proposed by the client, it may be accepted several times, which won't make sense in general. Extensions must implement their own requirements. For this purpose, the list of previously accepted extensions is provided. This process doesn't allow the server to reorder extensions. It can only select a subset of the extensions proposed by the client. Other requirements, for example related to mandatory extensions or the order of extensions, may be implemented by overriding this method. Args: headers: request headers. extensions: optional list of supported extensions. Raises: InvalidHandshake: to abort the handshake with an HTTP 400 error. NSec-WebSocket-ExtensionscSg|]}t|qSrI)r rJ header_valuerIrIrLrMz>WebSocketServerProtocol.process_extensions..)get_allsumnameZprocess_request_paramsrappendr) rtrVZresponse_header_valueZextension_headersZaccepted_extensions header_valuesparsed_header_valuesrZrequest_paramsZ ext_factoryZresponse_params extensionrIrIrLprocess_extensionss4(     z*WebSocketServerProtocol.process_extensionsrWOptional[Subprotocol]cCs:d}|d}|r|rtdd|Dg}|||}|S)a Handle the Sec-WebSocket-Protocol HTTP request header. Return Sec-WebSocket-Protocol HTTP response header, which is the same as the selected subprotocol. Args: headers: request headers. available_subprotocols: optional list of supported subprotocols. Raises: InvalidHandshake: to abort the handshake with an HTTP 400 error. NSec-WebSocket-ProtocolcSrrI)r!rrIrIrLrMrz?WebSocketServerProtocol.process_subprotocol..)rrr9)rZrtrW subprotocolrrrIrIrLprocess_subprotocols z+WebSocketServerProtocol.process_subprotocolclient_subprotocolsSequence[Subprotocol]server_subprotocolscsL|jdur |Stt@}|sdSfdd}t||ddS)a@ Pick a subprotocol among those offered by the client. If several subprotocols are supported by the client and the server, the default implementation selects the preferred subprotocol by giving equal value to the priorities of the client and the server. If no subprotocol is supported by the client and the server, it proceeds without a subprotocol. This is unlikely to be the most useful implementation in practice. Many servers providing a subprotocol will require that the client uses that subprotocol. Such rules can be implemented in a subclass. You may also override this method with the ``select_subprotocol`` argument of :func:`serve` and :class:`WebSocketServerProtocol`. Args: client_subprotocols: list of subprotocols offered by the client. server_subprotocols: list of subprotocols available on the server. Returns: Optional[Subprotocol]: Selected subprotocol. :obj:`None` to continue without a subprotocol. Ncs||SN)index)prrrIrL&sz.)rr)rYsetsorted)rZrrr6priorityrIrrLr9s z*WebSocketServerProtocol.select_subprotocolc s\|IdH\}}|||}t|tr|IdH}ntdt|}|jtj ur-| |j s9t jjgdf}|durAt|t|} ||||_|||\} |_|||} |_t} t| | | durn| | d<| durv| | d<t|r|||j}|dur| || dtjj dd| d t!|"t jj#| |j$%d |&|S) a Perform the server side of the opening handshake. Args: origins: list of acceptable values of the Origin HTTP header; include :obj:`None` if the lack of an origin is acceptable. extensions: list of supported extensions, in order in which they should be tried. subprotocols: list of supported subprotocols, in order of decreasing preference. extra_headers: arbitrary HTTP headers to add to the response when the handshake succeeds. Returns: str: path of the URI of the request. Raises: InvalidHandshake: if the handshake fails. NrsServer is shutting down. rrrgTrhrjzconnection open)'rr8rrrrRrSrTstaterZCLOSEDZconnection_closed_excr< is_servingrwrxSERVICE_UNAVAILABLErr+rrKrr5rrrr*callablerupdaterrrrr#rSWITCHING_PROTOCOLSr3rZconnection_open) rZr4rVrWr7rrZearly_response_awaitableZearly_responserZextensions_headerZprotocol_headerrrIrIrLrm+sP             z!WebSocketServerProtocol.handshake)r:r;r<r1r3r=r4r>r5r?r6r@r7rAr8rBr9rCrDrrErF)r]r^rErFrErF)rErr)rsrrtrrurrErF)rrrrrEr)rtrr4r>rEr)rtrrVr?rEr)rtrrWr@rEr)rrrrrEr)NNNN) r4r>rVr?rWr@r7rArEr)__name__ __module__ __qualname____doc__Z is_clientZsiderQr_rcrrr8 staticmethodrrrr9rm __classcell__rIrIr[rLr0>s< ( o 1  U !-r0c@seZdZdZd0d1ddZd2d d Zd3ddZd3ddZd4ddZd4ddZ d4ddZ d5ddZ d6ddZ d4dd Z d4d!d"Zed7d$d%Zd8d&d'Zd9d.d/ZdS):r1a WebSocket server returned by :func:`serve`. This class provides the same interface as :class:`~asyncio.Server`, notably the :meth:`~asyncio.Server.close` and :meth:`~asyncio.Server.wait_closed` methods. It keeps track of WebSocket connections in order to close them properly when shutting down. Args: logger: logger for this server; defaults to ``logging.getLogger("websockets.server")``; see the :doc:`logging guide <../topics/logging>` for details. Nr3r=cCs.|dur td}||_t|_d|_|dS)NrG)rNrOr3r websockets close_task)rZr3rIrIrLrQs  zWebSocketServer.__init__r2asyncio.AbstractServerrErFcCs||_|jdus J|jD]8}|jtjkrd|}n"|jtjkr-d|dd}n|jtjkr8|}nt|}|j d|q | |_ dS)a Attach to a given :class:`~asyncio.Server`. Since :meth:`~asyncio.loop.create_server` doesn't support injecting a custom ``Server`` class, the easiest solution that doesn't rely on private :mod:`asyncio` APIs is to: - instantiate a :class:`WebSocketServer` - give the protocol factory a reference to that instance - call :meth:`~asyncio.loop.create_server` with the factory - attach the resulting :class:`~asyncio.Server` with this method Nz%s:%dz[%s]:%drzserver listening on %s)r2socketsfamilysocketAF_INET getsocknameAF_INET6AF_UNIXrr3rget_loopZ create_future closed_waiter)rZr2sockrrIrIrLwraps      zWebSocketServer.wrapprotocolr0cC|j|dS)z: Register a connection with this server. N)raddrZrrIrIrLr`zWebSocketServer.registercCr)z< Unregister a connection with this server. N)rremoverrIrIrLrrzWebSocketServer.unregistercCs&|jdur|||_dSdS)a Close the server. This method: * closes the underlying :class:`~asyncio.Server`; * rejects new WebSocket connections with an HTTP 503 (service unavailable) error; this happens when the server accepted the TCP connection but didn't complete the WebSocket opening handshake prior to closing; * closes open WebSocket connections with close code 1001 (going away). :meth:`close` is idempotent. N)rrrb_closerZrIrIrLrls zWebSocketServer.closecs|jd|j|jIdHtjdit|IdH|j r.cSsg|]}|jqSrI)rdrrIrIrLrMsz server closed)r) r3rr2rl wait_closedrnsleepr)rrwaitrZ set_resultrrIrIrLrs*      zWebSocketServer._closecst|jIdHdS)a Wait until the server is closed. When :meth:`wait_closed` returns, all TCP connections are closed and all connection handlers have returned. To ensure a fast shutdown, a connection handler should always be awaiting at least one of: * :meth:`~WebSocketServerProtocol.recv`: when the connection is closed, it raises :exc:`~websockets.exceptions.ConnectionClosedOK`; * :meth:`~WebSocketServerProtocol.wait_closed`: when the connection is closed, it returns. Then the connection handler is immediately notified of the shutdown; it can clean up and exit. N)rnshieldrrrIrIrLrszWebSocketServer.wait_closedasyncio.AbstractEventLoopcC |jS)z7 See :meth:`asyncio.Server.get_loop`. )r2rrrIrIrLr0 zWebSocketServer.get_loopboolcCr)z9 See :meth:`asyncio.Server.is_serving`. )r2rrrIrIrLr7rzWebSocketServer.is_servingc|jIdHdS)z< See :meth:`asyncio.Server.start_serving`. N)r2 start_servingrrIrIrLr>zWebSocketServer.start_servingcr)z< See :meth:`asyncio.Server.serve_forever`. N)r2 serve_foreverrrIrIrLrErzWebSocketServer.serve_foreverOptional[List[socket.socket]]cCs|jjS)z6 See :attr:`asyncio.Server.sockets`. )r2rrrIrIrLrLszWebSocketServer.socketscs|SrrIrrIrIrL __aenter__TszWebSocketServer.__aenter__exc_typeOptional[Type[BaseException]] exc_valueOptional[BaseException] tracebackOptional[TracebackType]cs||IdHdSr)rlrrZrrrrIrIrL __aexit__WszWebSocketServer.__aexit__r)r3r=)r2rrErF)rr0rErFr)rEr)rEr)rErrEr1rrrrrrrErF)rrrrrQrr`rrlrrrrrrpropertyrrrrIrIrIrLr1s"   !    1      r1c@speZdZdZ  d@ddddddddddddddddddAd.d/ZdBd1d2ZdCd9d:ZdDdd?ZeZ dS)EServea  Start a WebSocket server listening on ``host`` and ``port``. Whenever a client connects, the server creates a :class:`WebSocketServerProtocol`, performs the opening handshake, and delegates to the connection handler, ``ws_handler``. The handler receives the :class:`WebSocketServerProtocol` and uses it to send and receive messages. Once the handler completes, either normally or with an exception, the server performs the closing handshake and closes the connection. Awaiting :func:`serve` yields a :class:`WebSocketServer`. This object provides :meth:`~WebSocketServer.close` and :meth:`~WebSocketServer.wait_closed` methods for shutting down the server. :func:`serve` can be used as an asynchronous context manager:: stop = asyncio.Future() # set this future to exit the server async with serve(...): await stop The server is shut down automatically when exiting the context. Args: ws_handler: connection handler. It receives the WebSocket connection, which is a :class:`WebSocketServerProtocol`, in argument. host: network interfaces the server is bound to; see :meth:`~asyncio.loop.create_server` for details. port: TCP port the server listens on; see :meth:`~asyncio.loop.create_server` for details. create_protocol: factory for the :class:`asyncio.Protocol` managing the connection; defaults to :class:`WebSocketServerProtocol`; may be set to a wrapper or a subclass to customize connection handling. logger: logger for this server; defaults to ``logging.getLogger("websockets.server")``; see the :doc:`logging guide <../topics/logging>` for details. compression: shortcut that enables the "permessage-deflate" extension by default; may be set to :obj:`None` to disable compression; see the :doc:`compression guide <../topics/compression>` for details. origins: acceptable values of the ``Origin`` header; include :obj:`None` in the list if the lack of an origin is acceptable. This is useful for defending against Cross-Site WebSocket Hijacking attacks. extensions: list of supported extensions, in order in which they should be tried. subprotocols: list of supported subprotocols, in order of decreasing preference. extra_headers (Union[HeadersLike, Callable[[str, Headers], HeadersLike]]): arbitrary HTTP headers to add to the request; this can be a :data:`~websockets.datastructures.HeadersLike` or a callable taking the request path and headers in arguments and returning a :data:`~websockets.datastructures.HeadersLike`. process_request (Optional[Callable[[str, Headers], Awaitable[Optional[Tuple[http.HTTPStatus, HeadersLike, bytes]]]]]): intercept HTTP request before the opening handshake; see :meth:`~WebSocketServerProtocol.process_request` for details. select_subprotocol: select a subprotocol supported by the client; see :meth:`~WebSocketServerProtocol.select_subprotocol` for details. See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``, ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``. Any other keyword arguments are passed the event loop's :meth:`~asyncio.loop.create_server` method. For example: * You can set ``ssl`` to a :class:`~ssl.SSLContext` to enable TLS. * You can set ``sock`` to a :obj:`~socket.socket` that you created outside of websockets. Returns: WebSocketServer: WebSocket server. Ndeflatei i)create_protocolr3 compressionr4r5r6r7r8r9 ping_interval ping_timeout close_timeoutmax_size max_queue read_limit write_limitr:r;host#Optional[Union[str, Sequence[str]]]port Optional[int]r2Optional[Callable[[Any], WebSocketServerProtocol]]r3r=r Optional[str]r4r>r5r?r6r@r7rAr8rBr9rCrOptional[float]rrrrrintrrDrrErFcKs|dd}|dur d}ntdt|dur|}|dd}|dur&t}ntdt|dur2|}|dd}|dd}|durGt}n|}td tt|d }|d du}|d krdt |}n |durot d || durwt | t j |t||fid|d|d|d| d|d|d|d|d|d|d|d|d|d|d| d| d| d| d|}|ddr|d d}|dur|dusJt j |j||fi|}n t j |j|||fi|}||_||_dS)!Ntimeout zrename timeout to close_timeoutklasszrename klass to create_protocol legacy_recvFrazremove loop argument)r3sslrzunsupported compression: rrsecurerrrrrrrr4r5r6r7r8r9r3unixr)poprRrSrTr0rnZget_event_loopr1rr ValueErrorr" functoolspartialrUZcreate_unix_server create_server_create_serverr<)rZr:rrrr3rr4r5r6r7r8r9rrrrrrrrDr rr_looprar<rfactoryrrrIrIrLrQs                   zServe.__init__r1cs |IdHSrrIrrIrIrLr+s zServe.__aenter__rrrrrrcs |j|jIdHdSr)r<rlrrrIrIrLr.s zServe.__aexit__%Generator[Any, None, WebSocketServer]cCs |Sr)__await_impl__ __await__rrIrIrLr9s zServe.__await__cs"|IdH}|j||jSr)rr<r)rZr2rIrIrLr=s zServe.__await_impl__)NN)*r:r;rrrrrr r3r=rr r4r>r5r?r6r@r7rAr8rBr9rCrr rr rr rrrrrr rr rDrrErFrr)rEr) rrrrrQrrrr__iter__rIrIrIrLras6W  x  rr:r;rr rDrrEcKst|f|dd|S)a[ Similar to :func:`serve`, but for listening on Unix sockets. This function builds upon the event loop's :meth:`~asyncio.loop.create_unix_server` method. It is only available on Unix. It's useful for deploying a server behind a reverse proxy such as nginx. Args: path: file system path to the Unix socket. T)rr)r.)r:rrDrIrIrLr/Jsr/3Callable[[WebSocketServerProtocol], Awaitable[Any]]cs>ttjdkrdfdd }|StttgttfS) Nrrfr0rErcs*ttttgttf||jIdHSr)rrr0rrrr)rfr:rIrL _ws_handlerms z)remove_path_argument.._ws_handler)rfr0rEr) rinspect signature parametersrrr0rr)r:r"rIr!rLrUcsrUr)r:r;rr rDrrEr)r:r;rEr )K __future__rrn email.utilsrrrwr#rNrrRtypesrtypingrrrrrr r r r r rr connectionrZdatastructuresrrr exceptionsrrrrrrrr5rrZextensions.permessage_deflaterrtrr r!r"r#r$r%r&r'Z compatibilityr)rmr*r+r,rr-__all__rZHeadersLikeOrCallablerxbytes HTTPResponser0r1rr.r/rUrIrIrIrLsN  8 $     NZg