Add files using upload-large-folder tool

.gitattributes

@@ -214,3 +214,4 @@ llmeval-env/lib/python3.10/site-packages/scipy/special/cython_special.cpython-31
 llmeval-env/lib/python3.10/site-packages/scipy/linalg/_flapack.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/scipy/io/_fast_matrix_market/_fmm_core.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 env-llmeval/lib/python3.10/site-packages/torch/lib/libtorch_cuda.so filter=lfs diff=lfs merge=lfs -text
+env-llmeval/lib/python3.10/site-packages/sklearn/_loss/_loss.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

env-llmeval/lib/python3.10/site-packages/aiohttp/__init__.py

@@ -0,0 +1,240 @@
+__version__ = "3.9.4"
+
+from typing import TYPE_CHECKING, Tuple
+
+from . import hdrs as hdrs
+from .client import (
+    BaseConnector as BaseConnector,
+    ClientConnectionError as ClientConnectionError,
+    ClientConnectorCertificateError as ClientConnectorCertificateError,
+    ClientConnectorError as ClientConnectorError,
+    ClientConnectorSSLError as ClientConnectorSSLError,
+    ClientError as ClientError,
+    ClientHttpProxyError as ClientHttpProxyError,
+    ClientOSError as ClientOSError,
+    ClientPayloadError as ClientPayloadError,
+    ClientProxyConnectionError as ClientProxyConnectionError,
+    ClientRequest as ClientRequest,
+    ClientResponse as ClientResponse,
+    ClientResponseError as ClientResponseError,
+    ClientSession as ClientSession,
+    ClientSSLError as ClientSSLError,
+    ClientTimeout as ClientTimeout,
+    ClientWebSocketResponse as ClientWebSocketResponse,
+    ContentTypeError as ContentTypeError,
+    Fingerprint as Fingerprint,
+    InvalidURL as InvalidURL,
+    NamedPipeConnector as NamedPipeConnector,
+    RequestInfo as RequestInfo,
+    ServerConnectionError as ServerConnectionError,
+    ServerDisconnectedError as ServerDisconnectedError,
+    ServerFingerprintMismatch as ServerFingerprintMismatch,
+    ServerTimeoutError as ServerTimeoutError,
+    TCPConnector as TCPConnector,
+    TooManyRedirects as TooManyRedirects,
+    UnixConnector as UnixConnector,
+    WSServerHandshakeError as WSServerHandshakeError,
+    request as request,
+)
+from .cookiejar import CookieJar as CookieJar, DummyCookieJar as DummyCookieJar
+from .formdata import FormData as FormData
+from .helpers import BasicAuth, ChainMapProxy, ETag
+from .http import (
+    HttpVersion as HttpVersion,
+    HttpVersion10 as HttpVersion10,
+    HttpVersion11 as HttpVersion11,
+    WebSocketError as WebSocketError,
+    WSCloseCode as WSCloseCode,
+    WSMessage as WSMessage,
+    WSMsgType as WSMsgType,
+)
+from .multipart import (
+    BadContentDispositionHeader as BadContentDispositionHeader,
+    BadContentDispositionParam as BadContentDispositionParam,
+    BodyPartReader as BodyPartReader,
+    MultipartReader as MultipartReader,
+    MultipartWriter as MultipartWriter,
+    content_disposition_filename as content_disposition_filename,
+    parse_content_disposition as parse_content_disposition,
+)
+from .payload import (
+    PAYLOAD_REGISTRY as PAYLOAD_REGISTRY,
+    AsyncIterablePayload as AsyncIterablePayload,
+    BufferedReaderPayload as BufferedReaderPayload,
+    BytesIOPayload as BytesIOPayload,
+    BytesPayload as BytesPayload,
+    IOBasePayload as IOBasePayload,
+    JsonPayload as JsonPayload,
+    Payload as Payload,
+    StringIOPayload as StringIOPayload,
+    StringPayload as StringPayload,
+    TextIOPayload as TextIOPayload,
+    get_payload as get_payload,
+    payload_type as payload_type,
+)
+from .payload_streamer import streamer as streamer
+from .resolver import (
+    AsyncResolver as AsyncResolver,
+    DefaultResolver as DefaultResolver,
+    ThreadedResolver as ThreadedResolver,
+)
+from .streams import (
+    EMPTY_PAYLOAD as EMPTY_PAYLOAD,
+    DataQueue as DataQueue,
+    EofStream as EofStream,
+    FlowControlDataQueue as FlowControlDataQueue,
+    StreamReader as StreamReader,
+)
+from .tracing import (
+    TraceConfig as TraceConfig,
+    TraceConnectionCreateEndParams as TraceConnectionCreateEndParams,
+    TraceConnectionCreateStartParams as TraceConnectionCreateStartParams,
+    TraceConnectionQueuedEndParams as TraceConnectionQueuedEndParams,
+    TraceConnectionQueuedStartParams as TraceConnectionQueuedStartParams,
+    TraceConnectionReuseconnParams as TraceConnectionReuseconnParams,
+    TraceDnsCacheHitParams as TraceDnsCacheHitParams,
+    TraceDnsCacheMissParams as TraceDnsCacheMissParams,
+    TraceDnsResolveHostEndParams as TraceDnsResolveHostEndParams,
+    TraceDnsResolveHostStartParams as TraceDnsResolveHostStartParams,
+    TraceRequestChunkSentParams as TraceRequestChunkSentParams,
+    TraceRequestEndParams as TraceRequestEndParams,
+    TraceRequestExceptionParams as TraceRequestExceptionParams,
+    TraceRequestRedirectParams as TraceRequestRedirectParams,
+    TraceRequestStartParams as TraceRequestStartParams,
+    TraceResponseChunkReceivedParams as TraceResponseChunkReceivedParams,
+)
+
+if TYPE_CHECKING:
+    # At runtime these are lazy-loaded at the bottom of the file.
+    from .worker import (
+        GunicornUVLoopWebWorker as GunicornUVLoopWebWorker,
+        GunicornWebWorker as GunicornWebWorker,
+    )
+
+__all__: Tuple[str, ...] = (
+    "hdrs",
+    # client
+    "BaseConnector",
+    "ClientConnectionError",
+    "ClientConnectorCertificateError",
+    "ClientConnectorError",
+    "ClientConnectorSSLError",
+    "ClientError",
+    "ClientHttpProxyError",
+    "ClientOSError",
+    "ClientPayloadError",
+    "ClientProxyConnectionError",
+    "ClientResponse",
+    "ClientRequest",
+    "ClientResponseError",
+    "ClientSSLError",
+    "ClientSession",
+    "ClientTimeout",
+    "ClientWebSocketResponse",
+    "ContentTypeError",
+    "Fingerprint",
+    "InvalidURL",
+    "RequestInfo",
+    "ServerConnectionError",
+    "ServerDisconnectedError",
+    "ServerFingerprintMismatch",
+    "ServerTimeoutError",
+    "TCPConnector",
+    "TooManyRedirects",
+    "UnixConnector",
+    "NamedPipeConnector",
+    "WSServerHandshakeError",
+    "request",
+    # cookiejar
+    "CookieJar",
+    "DummyCookieJar",
+    # formdata
+    "FormData",
+    # helpers
+    "BasicAuth",
+    "ChainMapProxy",
+    "ETag",
+    # http
+    "HttpVersion",
+    "HttpVersion10",
+    "HttpVersion11",
+    "WSMsgType",
+    "WSCloseCode",
+    "WSMessage",
+    "WebSocketError",
+    # multipart
+    "BadContentDispositionHeader",
+    "BadContentDispositionParam",
+    "BodyPartReader",
+    "MultipartReader",
+    "MultipartWriter",
+    "content_disposition_filename",
+    "parse_content_disposition",
+    # payload
+    "AsyncIterablePayload",
+    "BufferedReaderPayload",
+    "BytesIOPayload",
+    "BytesPayload",
+    "IOBasePayload",
+    "JsonPayload",
+    "PAYLOAD_REGISTRY",
+    "Payload",
+    "StringIOPayload",
+    "StringPayload",
+    "TextIOPayload",
+    "get_payload",
+    "payload_type",
+    # payload_streamer
+    "streamer",
+    # resolver
+    "AsyncResolver",
+    "DefaultResolver",
+    "ThreadedResolver",
+    # streams
+    "DataQueue",
+    "EMPTY_PAYLOAD",
+    "EofStream",
+    "FlowControlDataQueue",
+    "StreamReader",
+    # tracing
+    "TraceConfig",
+    "TraceConnectionCreateEndParams",
+    "TraceConnectionCreateStartParams",
+    "TraceConnectionQueuedEndParams",
+    "TraceConnectionQueuedStartParams",
+    "TraceConnectionReuseconnParams",
+    "TraceDnsCacheHitParams",
+    "TraceDnsCacheMissParams",
+    "TraceDnsResolveHostEndParams",
+    "TraceDnsResolveHostStartParams",
+    "TraceRequestChunkSentParams",
+    "TraceRequestEndParams",
+    "TraceRequestExceptionParams",
+    "TraceRequestRedirectParams",
+    "TraceRequestStartParams",
+    "TraceResponseChunkReceivedParams",
+    # workers (imported lazily with __getattr__)
+    "GunicornUVLoopWebWorker",
+    "GunicornWebWorker",
+)
+
+
+def __dir__() -> Tuple[str, ...]:
+    return __all__ + ("__author__", "__doc__")
+
+
+def __getattr__(name: str) -> object:
+    global GunicornUVLoopWebWorker, GunicornWebWorker
+
+    # Importing gunicorn takes a long time (>100ms), so only import if actually needed.
+    if name in ("GunicornUVLoopWebWorker", "GunicornWebWorker"):
+        try:
+            from .worker import GunicornUVLoopWebWorker as guv, GunicornWebWorker as gw
+        except ImportError:
+            return None
+
+        GunicornUVLoopWebWorker = guv  # type: ignore[misc]
+        GunicornWebWorker = gw  # type: ignore[misc]
+        return guv if name == "GunicornUVLoopWebWorker" else gw
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")

env-llmeval/lib/python3.10/site-packages/aiohttp/_cparser.pxd

@@ -0,0 +1,158 @@
+from libc.stdint cimport int32_t, uint8_t, uint16_t, uint64_t
+
+
+cdef extern from "../vendor/llhttp/build/llhttp.h":
+
+    struct llhttp__internal_s:
+        int32_t _index
+        void* _span_pos0
+        void* _span_cb0
+        int32_t error
+        const char* reason
+        const char* error_pos
+        void* data
+        void* _current
+        uint64_t content_length
+        uint8_t type
+        uint8_t method
+        uint8_t http_major
+        uint8_t http_minor
+        uint8_t header_state
+        uint8_t lenient_flags
+        uint8_t upgrade
+        uint8_t finish
+        uint16_t flags
+        uint16_t status_code
+        void* settings
+
+    ctypedef llhttp__internal_s llhttp__internal_t
+    ctypedef llhttp__internal_t llhttp_t
+
+    ctypedef int (*llhttp_data_cb)(llhttp_t*, const char *at, size_t length) except -1
+    ctypedef int (*llhttp_cb)(llhttp_t*) except -1
+
+    struct llhttp_settings_s:
+        llhttp_cb      on_message_begin
+        llhttp_data_cb on_url
+        llhttp_data_cb on_status
+        llhttp_data_cb on_header_field
+        llhttp_data_cb on_header_value
+        llhttp_cb      on_headers_complete
+        llhttp_data_cb on_body
+        llhttp_cb      on_message_complete
+        llhttp_cb      on_chunk_header
+        llhttp_cb      on_chunk_complete
+
+        llhttp_cb      on_url_complete
+        llhttp_cb      on_status_complete
+        llhttp_cb      on_header_field_complete
+        llhttp_cb      on_header_value_complete
+
+    ctypedef llhttp_settings_s llhttp_settings_t
+
+    enum llhttp_errno:
+        HPE_OK,
+        HPE_INTERNAL,
+        HPE_STRICT,
+        HPE_LF_EXPECTED,
+        HPE_UNEXPECTED_CONTENT_LENGTH,
+        HPE_CLOSED_CONNECTION,
+        HPE_INVALID_METHOD,
+        HPE_INVALID_URL,
+        HPE_INVALID_CONSTANT,
+        HPE_INVALID_VERSION,
+        HPE_INVALID_HEADER_TOKEN,
+        HPE_INVALID_CONTENT_LENGTH,
+        HPE_INVALID_CHUNK_SIZE,
+        HPE_INVALID_STATUS,
+        HPE_INVALID_EOF_STATE,
+        HPE_INVALID_TRANSFER_ENCODING,
+        HPE_CB_MESSAGE_BEGIN,
+        HPE_CB_HEADERS_COMPLETE,
+        HPE_CB_MESSAGE_COMPLETE,
+        HPE_CB_CHUNK_HEADER,
+        HPE_CB_CHUNK_COMPLETE,
+        HPE_PAUSED,
+        HPE_PAUSED_UPGRADE,
+        HPE_USER
+
+    ctypedef llhttp_errno llhttp_errno_t
+
+    enum llhttp_flags:
+        F_CHUNKED,
+        F_CONTENT_LENGTH
+
+    enum llhttp_type:
+        HTTP_REQUEST,
+        HTTP_RESPONSE,
+        HTTP_BOTH
+
+    enum llhttp_method:
+        HTTP_DELETE,
+        HTTP_GET,
+        HTTP_HEAD,
+        HTTP_POST,
+        HTTP_PUT,
+        HTTP_CONNECT,
+        HTTP_OPTIONS,
+        HTTP_TRACE,
+        HTTP_COPY,
+        HTTP_LOCK,
+        HTTP_MKCOL,
+        HTTP_MOVE,
+        HTTP_PROPFIND,
+        HTTP_PROPPATCH,
+        HTTP_SEARCH,
+        HTTP_UNLOCK,
+        HTTP_BIND,
+        HTTP_REBIND,
+        HTTP_UNBIND,
+        HTTP_ACL,
+        HTTP_REPORT,
+        HTTP_MKACTIVITY,
+        HTTP_CHECKOUT,
+        HTTP_MERGE,
+        HTTP_MSEARCH,
+        HTTP_NOTIFY,
+        HTTP_SUBSCRIBE,
+        HTTP_UNSUBSCRIBE,
+        HTTP_PATCH,
+        HTTP_PURGE,
+        HTTP_MKCALENDAR,
+        HTTP_LINK,
+        HTTP_UNLINK,
+        HTTP_SOURCE,
+        HTTP_PRI,
+        HTTP_DESCRIBE,
+        HTTP_ANNOUNCE,
+        HTTP_SETUP,
+        HTTP_PLAY,
+        HTTP_PAUSE,
+        HTTP_TEARDOWN,
+        HTTP_GET_PARAMETER,
+        HTTP_SET_PARAMETER,
+        HTTP_REDIRECT,
+        HTTP_RECORD,
+        HTTP_FLUSH
+
+    ctypedef llhttp_method llhttp_method_t;
+
+    void llhttp_settings_init(llhttp_settings_t* settings)
+    void llhttp_init(llhttp_t* parser, llhttp_type type,
+                 const llhttp_settings_t* settings)
+
+    llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len)
+
+    int llhttp_should_keep_alive(const llhttp_t* parser)
+
+    void llhttp_resume_after_upgrade(llhttp_t* parser)
+
+    llhttp_errno_t llhttp_get_errno(const llhttp_t* parser)
+    const char* llhttp_get_error_reason(const llhttp_t* parser)
+    const char* llhttp_get_error_pos(const llhttp_t* parser)
+
+    const char* llhttp_method_name(llhttp_method_t method)
+
+    void llhttp_set_lenient_headers(llhttp_t* parser, int enabled)
+    void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled)
+    void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled)

env-llmeval/lib/python3.10/site-packages/aiohttp/_find_header.pxd

@@ -0,0 +1,2 @@
+cdef extern from "_find_header.h":
+    int find_header(char *, int)

env-llmeval/lib/python3.10/site-packages/aiohttp/_headers.pxi

@@ -0,0 +1,83 @@
+# The file is autogenerated from aiohttp/hdrs.py
+# Run ./tools/gen.py to update it after the origin changing.
+
+from . import hdrs
+cdef tuple headers = (
+    hdrs.ACCEPT,
+    hdrs.ACCEPT_CHARSET,
+    hdrs.ACCEPT_ENCODING,
+    hdrs.ACCEPT_LANGUAGE,
+    hdrs.ACCEPT_RANGES,
+    hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS,
+    hdrs.ACCESS_CONTROL_ALLOW_HEADERS,
+    hdrs.ACCESS_CONTROL_ALLOW_METHODS,
+    hdrs.ACCESS_CONTROL_ALLOW_ORIGIN,
+    hdrs.ACCESS_CONTROL_EXPOSE_HEADERS,
+    hdrs.ACCESS_CONTROL_MAX_AGE,
+    hdrs.ACCESS_CONTROL_REQUEST_HEADERS,
+    hdrs.ACCESS_CONTROL_REQUEST_METHOD,
+    hdrs.AGE,
+    hdrs.ALLOW,
+    hdrs.AUTHORIZATION,
+    hdrs.CACHE_CONTROL,
+    hdrs.CONNECTION,
+    hdrs.CONTENT_DISPOSITION,
+    hdrs.CONTENT_ENCODING,
+    hdrs.CONTENT_LANGUAGE,
+    hdrs.CONTENT_LENGTH,
+    hdrs.CONTENT_LOCATION,
+    hdrs.CONTENT_MD5,
+    hdrs.CONTENT_RANGE,
+    hdrs.CONTENT_TRANSFER_ENCODING,
+    hdrs.CONTENT_TYPE,
+    hdrs.COOKIE,
+    hdrs.DATE,
+    hdrs.DESTINATION,
+    hdrs.DIGEST,
+    hdrs.ETAG,
+    hdrs.EXPECT,
+    hdrs.EXPIRES,
+    hdrs.FORWARDED,
+    hdrs.FROM,
+    hdrs.HOST,
+    hdrs.IF_MATCH,
+    hdrs.IF_MODIFIED_SINCE,
+    hdrs.IF_NONE_MATCH,
+    hdrs.IF_RANGE,
+    hdrs.IF_UNMODIFIED_SINCE,
+    hdrs.KEEP_ALIVE,
+    hdrs.LAST_EVENT_ID,
+    hdrs.LAST_MODIFIED,
+    hdrs.LINK,
+    hdrs.LOCATION,
+    hdrs.MAX_FORWARDS,
+    hdrs.ORIGIN,
+    hdrs.PRAGMA,
+    hdrs.PROXY_AUTHENTICATE,
+    hdrs.PROXY_AUTHORIZATION,
+    hdrs.RANGE,
+    hdrs.REFERER,
+    hdrs.RETRY_AFTER,
+    hdrs.SEC_WEBSOCKET_ACCEPT,
+    hdrs.SEC_WEBSOCKET_EXTENSIONS,
+    hdrs.SEC_WEBSOCKET_KEY,
+    hdrs.SEC_WEBSOCKET_KEY1,
+    hdrs.SEC_WEBSOCKET_PROTOCOL,
+    hdrs.SEC_WEBSOCKET_VERSION,
+    hdrs.SERVER,
+    hdrs.SET_COOKIE,
+    hdrs.TE,
+    hdrs.TRAILER,
+    hdrs.TRANSFER_ENCODING,
+    hdrs.URI,
+    hdrs.UPGRADE,
+    hdrs.USER_AGENT,
+    hdrs.VARY,
+    hdrs.VIA,
+    hdrs.WWW_AUTHENTICATE,
+    hdrs.WANT_DIGEST,
+    hdrs.WARNING,
+    hdrs.X_FORWARDED_FOR,
+    hdrs.X_FORWARDED_HOST,
+    hdrs.X_FORWARDED_PROTO,
+)

env-llmeval/lib/python3.10/site-packages/aiohttp/_helpers.pyi

@@ -0,0 +1,6 @@
+from typing import Any
+
+class reify:
+    def __init__(self, wrapped: Any) -> None: ...
+    def __get__(self, inst: Any, owner: Any) -> Any: ...
+    def __set__(self, inst: Any, value: Any) -> None: ...

env-llmeval/lib/python3.10/site-packages/aiohttp/_helpers.pyx

@@ -0,0 +1,35 @@
+cdef class reify:
+    """Use as a class method decorator.  It operates almost exactly like
+    the Python `@property` decorator, but it puts the result of the
+    method it decorates into the instance dict after the first call,
+    effectively replacing the function it decorates with an instance
+    variable.  It is, in Python parlance, a data descriptor.
+
+    """
+
+    cdef object wrapped
+    cdef object name
+
+    def __init__(self, wrapped):
+        self.wrapped = wrapped
+        self.name = wrapped.__name__
+
+    @property
+    def __doc__(self):
+        return self.wrapped.__doc__
+
+    def __get__(self, inst, owner):
+        try:
+            try:
+                return inst._cache[self.name]
+            except KeyError:
+                val = self.wrapped(inst)
+                inst._cache[self.name] = val
+                return val
+        except AttributeError:
+            if inst is None:
+                return self
+            raise
+
+    def __set__(self, inst, value):
+        raise AttributeError("reified property is read-only")

env-llmeval/lib/python3.10/site-packages/aiohttp/_http_parser.pyx

@@ -0,0 +1,838 @@
+#cython: language_level=3
+#
+# Based on https://github.com/MagicStack/httptools
+#
+
+from cpython cimport (
+    Py_buffer,
+    PyBUF_SIMPLE,
+    PyBuffer_Release,
+    PyBytes_AsString,
+    PyBytes_AsStringAndSize,
+    PyObject_GetBuffer,
+)
+from cpython.mem cimport PyMem_Free, PyMem_Malloc
+from libc.limits cimport ULLONG_MAX
+from libc.string cimport memcpy
+
+from multidict import CIMultiDict as _CIMultiDict, CIMultiDictProxy as _CIMultiDictProxy
+from yarl import URL as _URL
+
+from aiohttp import hdrs
+from aiohttp.helpers import DEBUG, set_exception
+
+from .http_exceptions import (
+    BadHttpMessage,
+    BadStatusLine,
+    ContentLengthError,
+    InvalidHeader,
+    InvalidURLError,
+    LineTooLong,
+    PayloadEncodingError,
+    TransferEncodingError,
+)
+from .http_parser import DeflateBuffer as _DeflateBuffer
+from .http_writer import (
+    HttpVersion as _HttpVersion,
+    HttpVersion10 as _HttpVersion10,
+    HttpVersion11 as _HttpVersion11,
+)
+from .streams import EMPTY_PAYLOAD as _EMPTY_PAYLOAD, StreamReader as _StreamReader
+
+cimport cython
+
+from aiohttp cimport _cparser as cparser
+
+include "_headers.pxi"
+
+from aiohttp cimport _find_header
+
+DEF DEFAULT_FREELIST_SIZE = 250
+
+cdef extern from "Python.h":
+    int PyByteArray_Resize(object, Py_ssize_t) except -1
+    Py_ssize_t PyByteArray_Size(object) except -1
+    char* PyByteArray_AsString(object)
+
+__all__ = ('HttpRequestParser', 'HttpResponseParser',
+           'RawRequestMessage', 'RawResponseMessage')
+
+cdef object URL = _URL
+cdef object URL_build = URL.build
+cdef object CIMultiDict = _CIMultiDict
+cdef object CIMultiDictProxy = _CIMultiDictProxy
+cdef object HttpVersion = _HttpVersion
+cdef object HttpVersion10 = _HttpVersion10
+cdef object HttpVersion11 = _HttpVersion11
+cdef object SEC_WEBSOCKET_KEY1 = hdrs.SEC_WEBSOCKET_KEY1
+cdef object CONTENT_ENCODING = hdrs.CONTENT_ENCODING
+cdef object EMPTY_PAYLOAD = _EMPTY_PAYLOAD
+cdef object StreamReader = _StreamReader
+cdef object DeflateBuffer = _DeflateBuffer
+
+
+cdef inline object extend(object buf, const char* at, size_t length):
+    cdef Py_ssize_t s
+    cdef char* ptr
+    s = PyByteArray_Size(buf)
+    PyByteArray_Resize(buf, s + length)
+    ptr = PyByteArray_AsString(buf)
+    memcpy(ptr + s, at, length)
+
+
+DEF METHODS_COUNT = 46;
+
+cdef list _http_method = []
+
+for i in range(METHODS_COUNT):
+    _http_method.append(
+        cparser.llhttp_method_name(<cparser.llhttp_method_t> i).decode('ascii'))
+
+
+cdef inline str http_method_str(int i):
+    if i < METHODS_COUNT:
+        return <str>_http_method[i]
+    else:
+        return "<unknown>"
+
+cdef inline object find_header(bytes raw_header):
+    cdef Py_ssize_t size
+    cdef char *buf
+    cdef int idx
+    PyBytes_AsStringAndSize(raw_header, &buf, &size)
+    idx = _find_header.find_header(buf, size)
+    if idx == -1:
+        return raw_header.decode('utf-8', 'surrogateescape')
+    return headers[idx]
+
+
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class RawRequestMessage:
+    cdef readonly str method
+    cdef readonly str path
+    cdef readonly object version  # HttpVersion
+    cdef readonly object headers  # CIMultiDict
+    cdef readonly object raw_headers  # tuple
+    cdef readonly object should_close
+    cdef readonly object compression
+    cdef readonly object upgrade
+    cdef readonly object chunked
+    cdef readonly object url  # yarl.URL
+
+    def __init__(self, method, path, version, headers, raw_headers,
+                 should_close, compression, upgrade, chunked, url):
+        self.method = method
+        self.path = path
+        self.version = version
+        self.headers = headers
+        self.raw_headers = raw_headers
+        self.should_close = should_close
+        self.compression = compression
+        self.upgrade = upgrade
+        self.chunked = chunked
+        self.url = url
+
+    def __repr__(self):
+        info = []
+        info.append(("method", self.method))
+        info.append(("path", self.path))
+        info.append(("version", self.version))
+        info.append(("headers", self.headers))
+        info.append(("raw_headers", self.raw_headers))
+        info.append(("should_close", self.should_close))
+        info.append(("compression", self.compression))
+        info.append(("upgrade", self.upgrade))
+        info.append(("chunked", self.chunked))
+        info.append(("url", self.url))
+        sinfo = ', '.join(name + '=' + repr(val) for name, val in info)
+        return '<RawRequestMessage(' + sinfo + ')>'
+
+    def _replace(self, **dct):
+        cdef RawRequestMessage ret
+        ret = _new_request_message(self.method,
+                                   self.path,
+                                   self.version,
+                                   self.headers,
+                                   self.raw_headers,
+                                   self.should_close,
+                                   self.compression,
+                                   self.upgrade,
+                                   self.chunked,
+                                   self.url)
+        if "method" in dct:
+            ret.method = dct["method"]
+        if "path" in dct:
+            ret.path = dct["path"]
+        if "version" in dct:
+            ret.version = dct["version"]
+        if "headers" in dct:
+            ret.headers = dct["headers"]
+        if "raw_headers" in dct:
+            ret.raw_headers = dct["raw_headers"]
+        if "should_close" in dct:
+            ret.should_close = dct["should_close"]
+        if "compression" in dct:
+            ret.compression = dct["compression"]
+        if "upgrade" in dct:
+            ret.upgrade = dct["upgrade"]
+        if "chunked" in dct:
+            ret.chunked = dct["chunked"]
+        if "url" in dct:
+            ret.url = dct["url"]
+        return ret
+
+cdef _new_request_message(str method,
+                           str path,
+                           object version,
+                           object headers,
+                           object raw_headers,
+                           bint should_close,
+                           object compression,
+                           bint upgrade,
+                           bint chunked,
+                           object url):
+    cdef RawRequestMessage ret
+    ret = RawRequestMessage.__new__(RawRequestMessage)
+    ret.method = method
+    ret.path = path
+    ret.version = version
+    ret.headers = headers
+    ret.raw_headers = raw_headers
+    ret.should_close = should_close
+    ret.compression = compression
+    ret.upgrade = upgrade
+    ret.chunked = chunked
+    ret.url = url
+    return ret
+
+
+@cython.freelist(DEFAULT_FREELIST_SIZE)
+cdef class RawResponseMessage:
+    cdef readonly object version  # HttpVersion
+    cdef readonly int code
+    cdef readonly str reason
+    cdef readonly object headers  # CIMultiDict
+    cdef readonly object raw_headers  # tuple
+    cdef readonly object should_close
+    cdef readonly object compression
+    cdef readonly object upgrade
+    cdef readonly object chunked
+
+    def __init__(self, version, code, reason, headers, raw_headers,
+                 should_close, compression, upgrade, chunked):
+        self.version = version
+        self.code = code
+        self.reason = reason
+        self.headers = headers
+        self.raw_headers = raw_headers
+        self.should_close = should_close
+        self.compression = compression
+        self.upgrade = upgrade
+        self.chunked = chunked
+
+    def __repr__(self):
+        info = []
+        info.append(("version", self.version))
+        info.append(("code", self.code))
+        info.append(("reason", self.reason))
+        info.append(("headers", self.headers))
+        info.append(("raw_headers", self.raw_headers))
+        info.append(("should_close", self.should_close))
+        info.append(("compression", self.compression))
+        info.append(("upgrade", self.upgrade))
+        info.append(("chunked", self.chunked))
+        sinfo = ', '.join(name + '=' + repr(val) for name, val in info)
+        return '<RawResponseMessage(' + sinfo + ')>'
+
+
+cdef _new_response_message(object version,
+                           int code,
+                           str reason,
+                           object headers,
+                           object raw_headers,
+                           bint should_close,
+                           object compression,
+                           bint upgrade,
+                           bint chunked):
+    cdef RawResponseMessage ret
+    ret = RawResponseMessage.__new__(RawResponseMessage)
+    ret.version = version
+    ret.code = code
+    ret.reason = reason
+    ret.headers = headers
+    ret.raw_headers = raw_headers
+    ret.should_close = should_close
+    ret.compression = compression
+    ret.upgrade = upgrade
+    ret.chunked = chunked
+    return ret
+
+
+@cython.internal
+cdef class HttpParser:
+
+    cdef:
+        cparser.llhttp_t* _cparser
+        cparser.llhttp_settings_t* _csettings
+
+        bytearray _raw_name
+        bytearray _raw_value
+        bint      _has_value
+
+        object _protocol
+        object _loop
+        object _timer
+
+        size_t _max_line_size
+        size_t _max_field_size
+        size_t _max_headers
+        bint _response_with_body
+        bint _read_until_eof
+
+        bint    _started
+        object  _url
+        bytearray   _buf
+        str     _path
+        str     _reason
+        object  _headers
+        list    _raw_headers
+        bint    _upgraded
+        list    _messages
+        object  _payload
+        bint    _payload_error
+        object  _payload_exception
+        object  _last_error
+        bint    _auto_decompress
+        int     _limit
+
+        str     _content_encoding
+
+        Py_buffer py_buf
+
+    def __cinit__(self):
+        self._cparser = <cparser.llhttp_t*> \
+                                PyMem_Malloc(sizeof(cparser.llhttp_t))
+        if self._cparser is NULL:
+            raise MemoryError()
+
+        self._csettings = <cparser.llhttp_settings_t*> \
+                                PyMem_Malloc(sizeof(cparser.llhttp_settings_t))
+        if self._csettings is NULL:
+            raise MemoryError()
+
+    def __dealloc__(self):
+        PyMem_Free(self._cparser)
+        PyMem_Free(self._csettings)
+
+    cdef _init(
+        self, cparser.llhttp_type mode,
+        object protocol, object loop, int limit,
+        object timer=None,
+        size_t max_line_size=8190, size_t max_headers=32768,
+        size_t max_field_size=8190, payload_exception=None,
+        bint response_with_body=True, bint read_until_eof=False,
+        bint auto_decompress=True,
+    ):
+        cparser.llhttp_settings_init(self._csettings)
+        cparser.llhttp_init(self._cparser, mode, self._csettings)
+        self._cparser.data = <void*>self
+        self._cparser.content_length = 0
+
+        self._protocol = protocol
+        self._loop = loop
+        self._timer = timer
+
+        self._buf = bytearray()
+        self._payload = None
+        self._payload_error = 0
+        self._payload_exception = payload_exception
+        self._messages = []
+
+        self._raw_name = bytearray()
+        self._raw_value = bytearray()
+        self._has_value = False
+
+        self._max_line_size = max_line_size
+        self._max_headers = max_headers
+        self._max_field_size = max_field_size
+        self._response_with_body = response_with_body
+        self._read_until_eof = read_until_eof
+        self._upgraded = False
+        self._auto_decompress = auto_decompress
+        self._content_encoding = None
+
+        self._csettings.on_url = cb_on_url
+        self._csettings.on_status = cb_on_status
+        self._csettings.on_header_field = cb_on_header_field
+        self._csettings.on_header_value = cb_on_header_value
+        self._csettings.on_headers_complete = cb_on_headers_complete
+        self._csettings.on_body = cb_on_body
+        self._csettings.on_message_begin = cb_on_message_begin
+        self._csettings.on_message_complete = cb_on_message_complete
+        self._csettings.on_chunk_header = cb_on_chunk_header
+        self._csettings.on_chunk_complete = cb_on_chunk_complete
+
+        self._last_error = None
+        self._limit = limit
+
+    cdef _process_header(self):
+        if self._raw_name:
+            raw_name = bytes(self._raw_name)
+            raw_value = bytes(self._raw_value)
+
+            name = find_header(raw_name)
+            value = raw_value.decode('utf-8', 'surrogateescape')
+
+            self._headers.add(name, value)
+
+            if name is CONTENT_ENCODING:
+                self._content_encoding = value
+
+            PyByteArray_Resize(self._raw_name, 0)
+            PyByteArray_Resize(self._raw_value, 0)
+            self._has_value = False
+            self._raw_headers.append((raw_name, raw_value))
+
+    cdef _on_header_field(self, char* at, size_t length):
+        cdef Py_ssize_t size
+        cdef char *buf
+        if self._has_value:
+            self._process_header()
+
+        size = PyByteArray_Size(self._raw_name)
+        PyByteArray_Resize(self._raw_name, size + length)
+        buf = PyByteArray_AsString(self._raw_name)
+        memcpy(buf + size, at, length)
+
+    cdef _on_header_value(self, char* at, size_t length):
+        cdef Py_ssize_t size
+        cdef char *buf
+
+        size = PyByteArray_Size(self._raw_value)
+        PyByteArray_Resize(self._raw_value, size + length)
+        buf = PyByteArray_AsString(self._raw_value)
+        memcpy(buf + size, at, length)
+        self._has_value = True
+
+    cdef _on_headers_complete(self):
+        self._process_header()
+
+        method = http_method_str(self._cparser.method)
+        should_close = not cparser.llhttp_should_keep_alive(self._cparser)
+        upgrade = self._cparser.upgrade
+        chunked = self._cparser.flags & cparser.F_CHUNKED
+
+        raw_headers = tuple(self._raw_headers)
+        headers = CIMultiDictProxy(self._headers)
+
+        if upgrade or self._cparser.method == cparser.HTTP_CONNECT:
+            self._upgraded = True
+
+        # do not support old websocket spec
+        if SEC_WEBSOCKET_KEY1 in headers:
+            raise InvalidHeader(SEC_WEBSOCKET_KEY1)
+
+        encoding = None
+        enc = self._content_encoding
+        if enc is not None:
+            self._content_encoding = None
+            enc = enc.lower()
+            if enc in ('gzip', 'deflate', 'br'):
+                encoding = enc
+
+        if self._cparser.type == cparser.HTTP_REQUEST:
+            msg = _new_request_message(
+                method, self._path,
+                self.http_version(), headers, raw_headers,
+                should_close, encoding, upgrade, chunked, self._url)
+        else:
+            msg = _new_response_message(
+                self.http_version(), self._cparser.status_code, self._reason,
+                headers, raw_headers, should_close, encoding,
+                upgrade, chunked)
+
+        if (
+            ULLONG_MAX > self._cparser.content_length > 0 or chunked or
+            self._cparser.method == cparser.HTTP_CONNECT or
+            (self._cparser.status_code >= 199 and
+             self._cparser.content_length == 0 and
+             self._read_until_eof)
+        ):
+            payload = StreamReader(
+                self._protocol, timer=self._timer, loop=self._loop,
+                limit=self._limit)
+        else:
+            payload = EMPTY_PAYLOAD
+
+        self._payload = payload
+        if encoding is not None and self._auto_decompress:
+            self._payload = DeflateBuffer(payload, encoding)
+
+        if not self._response_with_body:
+            payload = EMPTY_PAYLOAD
+
+        self._messages.append((msg, payload))
+
+    cdef _on_message_complete(self):
+        self._payload.feed_eof()
+        self._payload = None
+
+    cdef _on_chunk_header(self):
+        self._payload.begin_http_chunk_receiving()
+
+    cdef _on_chunk_complete(self):
+        self._payload.end_http_chunk_receiving()
+
+    cdef object _on_status_complete(self):
+        pass
+
+    cdef inline http_version(self):
+        cdef cparser.llhttp_t* parser = self._cparser
+
+        if parser.http_major == 1:
+            if parser.http_minor == 0:
+                return HttpVersion10
+            elif parser.http_minor == 1:
+                return HttpVersion11
+
+        return HttpVersion(parser.http_major, parser.http_minor)
+
+    ### Public API ###
+
+    def feed_eof(self):
+        cdef bytes desc
+
+        if self._payload is not None:
+            if self._cparser.flags & cparser.F_CHUNKED:
+                raise TransferEncodingError(
+                    "Not enough data for satisfy transfer length header.")
+            elif self._cparser.flags & cparser.F_CONTENT_LENGTH:
+                raise ContentLengthError(
+                    "Not enough data for satisfy content length header.")
+            elif cparser.llhttp_get_errno(self._cparser) != cparser.HPE_OK:
+                desc = cparser.llhttp_get_error_reason(self._cparser)
+                raise PayloadEncodingError(desc.decode('latin-1'))
+            else:
+                self._payload.feed_eof()
+        elif self._started:
+            self._on_headers_complete()
+            if self._messages:
+                return self._messages[-1][0]
+
+    def feed_data(self, data):
+        cdef:
+            size_t data_len
+            size_t nb
+            cdef cparser.llhttp_errno_t errno
+
+        PyObject_GetBuffer(data, &self.py_buf, PyBUF_SIMPLE)
+        data_len = <size_t>self.py_buf.len
+
+        errno = cparser.llhttp_execute(
+            self._cparser,
+            <char*>self.py_buf.buf,
+            data_len)
+
+        if errno is cparser.HPE_PAUSED_UPGRADE:
+            cparser.llhttp_resume_after_upgrade(self._cparser)
+
+            nb = cparser.llhttp_get_error_pos(self._cparser) - <char*>self.py_buf.buf
+
+        PyBuffer_Release(&self.py_buf)
+
+        if errno not in (cparser.HPE_OK, cparser.HPE_PAUSED_UPGRADE):
+            if self._payload_error == 0:
+                if self._last_error is not None:
+                    ex = self._last_error
+                    self._last_error = None
+                else:
+                    after = cparser.llhttp_get_error_pos(self._cparser)
+                    before = data[:after - <char*>self.py_buf.buf]
+                    after_b = after.split(b"\r\n", 1)[0]
+                    before = before.rsplit(b"\r\n", 1)[-1]
+                    data = before + after_b
+                    pointer = " " * (len(repr(before))-1) + "^"
+                    ex = parser_error_from_errno(self._cparser, data, pointer)
+                self._payload = None
+                raise ex
+
+        if self._messages:
+            messages = self._messages
+            self._messages = []
+        else:
+            messages = ()
+
+        if self._upgraded:
+            return messages, True, data[nb:]
+        else:
+            return messages, False, b''
+
+    def set_upgraded(self, val):
+        self._upgraded = val
+
+
+cdef class HttpRequestParser(HttpParser):
+
+    def __init__(
+        self, protocol, loop, int limit, timer=None,
+        size_t max_line_size=8190, size_t max_headers=32768,
+        size_t max_field_size=8190, payload_exception=None,
+        bint response_with_body=True, bint read_until_eof=False,
+        bint auto_decompress=True,
+    ):
+        self._init(cparser.HTTP_REQUEST, protocol, loop, limit, timer,
+                   max_line_size, max_headers, max_field_size,
+                   payload_exception, response_with_body, read_until_eof,
+                   auto_decompress)
+
+    cdef object _on_status_complete(self):
+        cdef int idx1, idx2
+        if not self._buf:
+            return
+        self._path = self._buf.decode('utf-8', 'surrogateescape')
+        try:
+            idx3 = len(self._path)
+            if self._cparser.method == cparser.HTTP_CONNECT:
+                # authority-form,
+                # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.3
+                self._url = URL.build(authority=self._path, encoded=True)
+            elif idx3 > 1 and self._path[0] == '/':
+                # origin-form,
+                # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.1
+                idx1 = self._path.find("?")
+                if idx1 == -1:
+                    query = ""
+                    idx2 = self._path.find("#")
+                    if idx2 == -1:
+                        path = self._path
+                        fragment = ""
+                    else:
+                        path = self._path[0: idx2]
+                        fragment = self._path[idx2+1:]
+
+                else:
+                    path = self._path[0:idx1]
+                    idx1 += 1
+                    idx2 = self._path.find("#", idx1+1)
+                    if idx2 == -1:
+                        query = self._path[idx1:]
+                        fragment = ""
+                    else:
+                        query = self._path[idx1: idx2]
+                        fragment = self._path[idx2+1:]
+
+                self._url = URL.build(
+                    path=path,
+                    query_string=query,
+                    fragment=fragment,
+                    encoded=True,
+                )
+            else:
+                # absolute-form for proxy maybe,
+                # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.2
+                self._url = URL(self._path, encoded=True)
+        finally:
+            PyByteArray_Resize(self._buf, 0)
+
+
+cdef class HttpResponseParser(HttpParser):
+
+    def __init__(
+        self, protocol, loop, int limit, timer=None,
+            size_t max_line_size=8190, size_t max_headers=32768,
+            size_t max_field_size=8190, payload_exception=None,
+            bint response_with_body=True, bint read_until_eof=False,
+            bint auto_decompress=True
+    ):
+        self._init(cparser.HTTP_RESPONSE, protocol, loop, limit, timer,
+                   max_line_size, max_headers, max_field_size,
+                   payload_exception, response_with_body, read_until_eof,
+                   auto_decompress)
+        # Use strict parsing on dev mode, so users are warned about broken servers.
+        if not DEBUG:
+            cparser.llhttp_set_lenient_headers(self._cparser, 1)
+            cparser.llhttp_set_lenient_optional_cr_before_lf(self._cparser, 1)
+            cparser.llhttp_set_lenient_spaces_after_chunk_size(self._cparser, 1)
+
+    cdef object _on_status_complete(self):
+        if self._buf:
+            self._reason = self._buf.decode('utf-8', 'surrogateescape')
+            PyByteArray_Resize(self._buf, 0)
+        else:
+            self._reason = self._reason or ''
+
+cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+
+    pyparser._started = True
+    pyparser._headers = CIMultiDict()
+    pyparser._raw_headers = []
+    PyByteArray_Resize(pyparser._buf, 0)
+    pyparser._path = None
+    pyparser._reason = None
+    return 0
+
+
+cdef int cb_on_url(cparser.llhttp_t* parser,
+                   const char *at, size_t length) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    try:
+        if length > pyparser._max_line_size:
+            raise LineTooLong(
+                'Status line is too long', pyparser._max_line_size, length)
+        extend(pyparser._buf, at, length)
+    except BaseException as ex:
+        pyparser._last_error = ex
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_status(cparser.llhttp_t* parser,
+                      const char *at, size_t length) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    cdef str reason
+    try:
+        if length > pyparser._max_line_size:
+            raise LineTooLong(
+                'Status line is too long', pyparser._max_line_size, length)
+        extend(pyparser._buf, at, length)
+    except BaseException as ex:
+        pyparser._last_error = ex
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_header_field(cparser.llhttp_t* parser,
+                            const char *at, size_t length) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    cdef Py_ssize_t size
+    try:
+        pyparser._on_status_complete()
+        size = len(pyparser._raw_name) + length
+        if size > pyparser._max_field_size:
+            raise LineTooLong(
+                'Header name is too long', pyparser._max_field_size, size)
+        pyparser._on_header_field(at, length)
+    except BaseException as ex:
+        pyparser._last_error = ex
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_header_value(cparser.llhttp_t* parser,
+                            const char *at, size_t length) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    cdef Py_ssize_t size
+    try:
+        size = len(pyparser._raw_value) + length
+        if size > pyparser._max_field_size:
+            raise LineTooLong(
+                'Header value is too long', pyparser._max_field_size, size)
+        pyparser._on_header_value(at, length)
+    except BaseException as ex:
+        pyparser._last_error = ex
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    try:
+        pyparser._on_status_complete()
+        pyparser._on_headers_complete()
+    except BaseException as exc:
+        pyparser._last_error = exc
+        return -1
+    else:
+        if (
+            pyparser._cparser.upgrade or
+            pyparser._cparser.method == cparser.HTTP_CONNECT
+        ):
+            return 2
+        else:
+            return 0
+
+
+cdef int cb_on_body(cparser.llhttp_t* parser,
+                    const char *at, size_t length) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    cdef bytes body = at[:length]
+    try:
+        pyparser._payload.feed_data(body, length)
+    except BaseException as underlying_exc:
+        reraised_exc = underlying_exc
+        if pyparser._payload_exception is not None:
+            reraised_exc = pyparser._payload_exception(str(underlying_exc))
+
+        set_exception(pyparser._payload, reraised_exc, underlying_exc)
+
+        pyparser._payload_error = 1
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    try:
+        pyparser._started = False
+        pyparser._on_message_complete()
+    except BaseException as exc:
+        pyparser._last_error = exc
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    try:
+        pyparser._on_chunk_header()
+    except BaseException as exc:
+        pyparser._last_error = exc
+        return -1
+    else:
+        return 0
+
+
+cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1:
+    cdef HttpParser pyparser = <HttpParser>parser.data
+    try:
+        pyparser._on_chunk_complete()
+    except BaseException as exc:
+        pyparser._last_error = exc
+        return -1
+    else:
+        return 0
+
+
+cdef parser_error_from_errno(cparser.llhttp_t* parser, data, pointer):
+    cdef cparser.llhttp_errno_t errno = cparser.llhttp_get_errno(parser)
+    cdef bytes desc = cparser.llhttp_get_error_reason(parser)
+
+    err_msg = "{}:\n\n  {!r}\n  {}".format(desc.decode("latin-1"), data, pointer)
+
+    if errno in {cparser.HPE_CB_MESSAGE_BEGIN,
+                 cparser.HPE_CB_HEADERS_COMPLETE,
+                 cparser.HPE_CB_MESSAGE_COMPLETE,
+                 cparser.HPE_CB_CHUNK_HEADER,
+                 cparser.HPE_CB_CHUNK_COMPLETE,
+                 cparser.HPE_INVALID_CONSTANT,
+                 cparser.HPE_INVALID_HEADER_TOKEN,
+                 cparser.HPE_INVALID_CONTENT_LENGTH,
+                 cparser.HPE_INVALID_CHUNK_SIZE,
+                 cparser.HPE_INVALID_EOF_STATE,
+                 cparser.HPE_INVALID_TRANSFER_ENCODING}:
+        return BadHttpMessage(err_msg)
+    elif errno in {cparser.HPE_INVALID_STATUS,
+                   cparser.HPE_INVALID_METHOD,
+                   cparser.HPE_INVALID_VERSION}:
+        return BadStatusLine(error=err_msg)
+    elif errno == cparser.HPE_INVALID_URL:
+        return InvalidURLError(err_msg)
+
+    return BadHttpMessage(err_msg)

env-llmeval/lib/python3.10/site-packages/aiohttp/_http_writer.pyx

@@ -0,0 +1,163 @@
+from cpython.bytes cimport PyBytes_FromStringAndSize
+from cpython.exc cimport PyErr_NoMemory
+from cpython.mem cimport PyMem_Free, PyMem_Malloc, PyMem_Realloc
+from cpython.object cimport PyObject_Str
+from libc.stdint cimport uint8_t, uint64_t
+from libc.string cimport memcpy
+
+from multidict import istr
+
+DEF BUF_SIZE = 16 * 1024  # 16KiB
+cdef char BUFFER[BUF_SIZE]
+
+cdef object _istr = istr
+
+
+# ----------------- writer ---------------------------
+
+cdef struct Writer:
+    char *buf
+    Py_ssize_t size
+    Py_ssize_t pos
+
+
+cdef inline void _init_writer(Writer* writer):
+    writer.buf = &BUFFER[0]
+    writer.size = BUF_SIZE
+    writer.pos = 0
+
+
+cdef inline void _release_writer(Writer* writer):
+    if writer.buf != BUFFER:
+        PyMem_Free(writer.buf)
+
+
+cdef inline int _write_byte(Writer* writer, uint8_t ch):
+    cdef char * buf
+    cdef Py_ssize_t size
+
+    if writer.pos == writer.size:
+        # reallocate
+        size = writer.size + BUF_SIZE
+        if writer.buf == BUFFER:
+            buf = <char*>PyMem_Malloc(size)
+            if buf == NULL:
+                PyErr_NoMemory()
+                return -1
+            memcpy(buf, writer.buf, writer.size)
+        else:
+            buf = <char*>PyMem_Realloc(writer.buf, size)
+            if buf == NULL:
+                PyErr_NoMemory()
+                return -1
+        writer.buf = buf
+        writer.size = size
+    writer.buf[writer.pos] = <char>ch
+    writer.pos += 1
+    return 0
+
+
+cdef inline int _write_utf8(Writer* writer, Py_UCS4 symbol):
+    cdef uint64_t utf = <uint64_t> symbol
+
+    if utf < 0x80:
+        return _write_byte(writer, <uint8_t>utf)
+    elif utf < 0x800:
+        if _write_byte(writer, <uint8_t>(0xc0 | (utf >> 6))) < 0:
+            return -1
+        return _write_byte(writer,  <uint8_t>(0x80 | (utf & 0x3f)))
+    elif 0xD800 <= utf <= 0xDFFF:
+        # surogate pair, ignored
+        return 0
+    elif utf < 0x10000:
+        if _write_byte(writer, <uint8_t>(0xe0 | (utf >> 12))) < 0:
+            return -1
+        if _write_byte(writer, <uint8_t>(0x80 | ((utf >> 6) & 0x3f))) < 0:
+            return -1
+        return _write_byte(writer, <uint8_t>(0x80 | (utf & 0x3f)))
+    elif utf > 0x10FFFF:
+        # symbol is too large
+        return 0
+    else:
+        if _write_byte(writer,  <uint8_t>(0xf0 | (utf >> 18))) < 0:
+            return -1
+        if _write_byte(writer,
+                       <uint8_t>(0x80 | ((utf >> 12) & 0x3f))) < 0:
+           return -1
+        if _write_byte(writer,
+                       <uint8_t>(0x80 | ((utf >> 6) & 0x3f))) < 0:
+            return -1
+        return _write_byte(writer, <uint8_t>(0x80 | (utf & 0x3f)))
+
+
+cdef inline int _write_str(Writer* writer, str s):
+    cdef Py_UCS4 ch
+    for ch in s:
+        if _write_utf8(writer, ch) < 0:
+            return -1
+
+
+# --------------- _serialize_headers ----------------------
+
+cdef str to_str(object s):
+    typ = type(s)
+    if typ is str:
+        return <str>s
+    elif typ is _istr:
+        return PyObject_Str(s)
+    elif not isinstance(s, str):
+        raise TypeError("Cannot serialize non-str key {!r}".format(s))
+    else:
+        return str(s)
+
+
+cdef void _safe_header(str string) except *:
+    if "\r" in string or "\n" in string:
+        raise ValueError(
+            "Newline or carriage return character detected in HTTP status message or "
+            "header. This is a potential security issue."
+        )
+
+
+def _serialize_headers(str status_line, headers):
+    cdef Writer writer
+    cdef object key
+    cdef object val
+    cdef bytes ret
+
+    _init_writer(&writer)
+
+    for key, val in headers.items():
+        _safe_header(to_str(key))
+        _safe_header(to_str(val))
+
+    try:
+        if _write_str(&writer, status_line) < 0:
+            raise
+        if _write_byte(&writer, b'\r') < 0:
+            raise
+        if _write_byte(&writer, b'\n') < 0:
+            raise
+
+        for key, val in headers.items():
+            if _write_str(&writer, to_str(key)) < 0:
+                raise
+            if _write_byte(&writer, b':') < 0:
+                raise
+            if _write_byte(&writer, b' ') < 0:
+                raise
+            if _write_str(&writer, to_str(val)) < 0:
+                raise
+            if _write_byte(&writer, b'\r') < 0:
+                raise
+            if _write_byte(&writer, b'\n') < 0:
+                raise
+
+        if _write_byte(&writer, b'\r') < 0:
+            raise
+        if _write_byte(&writer, b'\n') < 0:
+            raise
+
+        return PyBytes_FromStringAndSize(writer.buf, writer.pos)
+    finally:
+        _release_writer(&writer)

env-llmeval/lib/python3.10/site-packages/aiohttp/_websocket.pyx

@@ -0,0 +1,56 @@
+from cpython cimport PyBytes_AsString
+
+
+#from cpython cimport PyByteArray_AsString # cython still not exports that
+cdef extern from "Python.h":
+    char* PyByteArray_AsString(bytearray ba) except NULL
+
+from libc.stdint cimport uint32_t, uint64_t, uintmax_t
+
+
+def _websocket_mask_cython(object mask, object data):
+    """Note, this function mutates its `data` argument
+    """
+    cdef:
+        Py_ssize_t data_len, i
+        # bit operations on signed integers are implementation-specific
+        unsigned char * in_buf
+        const unsigned char * mask_buf
+        uint32_t uint32_msk
+        uint64_t uint64_msk
+
+    assert len(mask) == 4
+
+    if not isinstance(mask, bytes):
+        mask = bytes(mask)
+
+    if isinstance(data, bytearray):
+        data = <bytearray>data
+    else:
+        data = bytearray(data)
+
+    data_len = len(data)
+    in_buf = <unsigned char*>PyByteArray_AsString(data)
+    mask_buf = <const unsigned char*>PyBytes_AsString(mask)
+    uint32_msk = (<uint32_t*>mask_buf)[0]
+
+    # TODO: align in_data ptr to achieve even faster speeds
+    # does it need in python ?! malloc() always aligns to sizeof(long) bytes
+
+    if sizeof(size_t) >= 8:
+        uint64_msk = uint32_msk
+        uint64_msk = (uint64_msk << 32) | uint32_msk
+
+        while data_len >= 8:
+            (<uint64_t*>in_buf)[0] ^= uint64_msk
+            in_buf += 8
+            data_len -= 8
+
+
+    while data_len >= 4:
+        (<uint32_t*>in_buf)[0] ^= uint32_msk
+        in_buf += 4
+        data_len -= 4
+
+    for i in range(0, data_len):
+        in_buf[i] ^= mask_buf[i]

env-llmeval/lib/python3.10/site-packages/aiohttp/abc.py

@@ -0,0 +1,209 @@
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Sized
+from http.cookies import BaseCookie, Morsel
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+)
+
+from multidict import CIMultiDict
+from yarl import URL
+
+from .helpers import get_running_loop
+from .typedefs import LooseCookies
+
+if TYPE_CHECKING:
+    from .web_app import Application
+    from .web_exceptions import HTTPException
+    from .web_request import BaseRequest, Request
+    from .web_response import StreamResponse
+else:
+    BaseRequest = Request = Application = StreamResponse = None
+    HTTPException = None
+
+
+class AbstractRouter(ABC):
+    def __init__(self) -> None:
+        self._frozen = False
+
+    def post_init(self, app: Application) -> None:
+        """Post init stage.
+
+        Not an abstract method for sake of backward compatibility,
+        but if the router wants to be aware of the application
+        it can override this.
+        """
+
+    @property
+    def frozen(self) -> bool:
+        return self._frozen
+
+    def freeze(self) -> None:
+        """Freeze router."""
+        self._frozen = True
+
+    @abstractmethod
+    async def resolve(self, request: Request) -> "AbstractMatchInfo":
+        """Return MATCH_INFO for given request"""
+
+
+class AbstractMatchInfo(ABC):
+    @property  # pragma: no branch
+    @abstractmethod
+    def handler(self) -> Callable[[Request], Awaitable[StreamResponse]]:
+        """Execute matched request handler"""
+
+    @property
+    @abstractmethod
+    def expect_handler(
+        self,
+    ) -> Callable[[Request], Awaitable[Optional[StreamResponse]]]:
+        """Expect handler for 100-continue processing"""
+
+    @property  # pragma: no branch
+    @abstractmethod
+    def http_exception(self) -> Optional[HTTPException]:
+        """HTTPException instance raised on router's resolving, or None"""
+
+    @abstractmethod  # pragma: no branch
+    def get_info(self) -> Dict[str, Any]:
+        """Return a dict with additional info useful for introspection"""
+
+    @property  # pragma: no branch
+    @abstractmethod
+    def apps(self) -> Tuple[Application, ...]:
+        """Stack of nested applications.
+
+        Top level application is left-most element.
+
+        """
+
+    @abstractmethod
+    def add_app(self, app: Application) -> None:
+        """Add application to the nested apps stack."""
+
+    @abstractmethod
+    def freeze(self) -> None:
+        """Freeze the match info.
+
+        The method is called after route resolution.
+
+        After the call .add_app() is forbidden.
+
+        """
+
+
+class AbstractView(ABC):
+    """Abstract class based view."""
+
+    def __init__(self, request: Request) -> None:
+        self._request = request
+
+    @property
+    def request(self) -> Request:
+        """Request instance."""
+        return self._request
+
+    @abstractmethod
+    def __await__(self) -> Generator[Any, None, StreamResponse]:
+        """Execute the view handler."""
+
+
+class AbstractResolver(ABC):
+    """Abstract DNS resolver."""
+
+    @abstractmethod
+    async def resolve(self, host: str, port: int, family: int) -> List[Dict[str, Any]]:
+        """Return IP address for given hostname"""
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Release resolver"""
+
+
+if TYPE_CHECKING:
+    IterableBase = Iterable[Morsel[str]]
+else:
+    IterableBase = Iterable
+
+
+ClearCookiePredicate = Callable[["Morsel[str]"], bool]
+
+
+class AbstractCookieJar(Sized, IterableBase):
+    """Abstract Cookie Jar."""
+
+    def __init__(self, *, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
+        self._loop = get_running_loop(loop)
+
+    @abstractmethod
+    def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None:
+        """Clear all cookies if no predicate is passed."""
+
+    @abstractmethod
+    def clear_domain(self, domain: str) -> None:
+        """Clear all cookies for domain and all subdomains."""
+
+    @abstractmethod
+    def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None:
+        """Update cookies."""
+
+    @abstractmethod
+    def filter_cookies(self, request_url: URL) -> "BaseCookie[str]":
+        """Return the jar's cookies filtered by their attributes."""
+
+
+class AbstractStreamWriter(ABC):
+    """Abstract stream writer."""
+
+    buffer_size = 0
+    output_size = 0
+    length: Optional[int] = 0
+
+    @abstractmethod
+    async def write(self, chunk: bytes) -> None:
+        """Write chunk into stream."""
+
+    @abstractmethod
+    async def write_eof(self, chunk: bytes = b"") -> None:
+        """Write last chunk."""
+
+    @abstractmethod
+    async def drain(self) -> None:
+        """Flush the write buffer."""
+
+    @abstractmethod
+    def enable_compression(self, encoding: str = "deflate") -> None:
+        """Enable HTTP body compression"""
+
+    @abstractmethod
+    def enable_chunking(self) -> None:
+        """Enable HTTP chunked mode"""
+
+    @abstractmethod
+    async def write_headers(
+        self, status_line: str, headers: "CIMultiDict[str]"
+    ) -> None:
+        """Write HTTP headers"""
+
+
+class AbstractAccessLogger(ABC):
+    """Abstract writer to access log."""
+
+    def __init__(self, logger: logging.Logger, log_format: str) -> None:
+        self.logger = logger
+        self.log_format = log_format
+
+    @abstractmethod
+    def log(self, request: BaseRequest, response: StreamResponse, time: float) -> None:
+        """Emit log to logger."""

env-llmeval/lib/python3.10/site-packages/aiohttp/base_protocol.py

@@ -0,0 +1,95 @@
+import asyncio
+from typing import Optional, cast
+
+from .helpers import set_exception
+from .tcp_helpers import tcp_nodelay
+
+
+class BaseProtocol(asyncio.Protocol):
+    __slots__ = (
+        "_loop",
+        "_paused",
+        "_drain_waiter",
+        "_connection_lost",
+        "_reading_paused",
+        "transport",
+    )
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop: asyncio.AbstractEventLoop = loop
+        self._paused = False
+        self._drain_waiter: Optional[asyncio.Future[None]] = None
+        self._reading_paused = False
+
+        self.transport: Optional[asyncio.Transport] = None
+
+    @property
+    def connected(self) -> bool:
+        """Return True if the connection is open."""
+        return self.transport is not None
+
+    def pause_writing(self) -> None:
+        assert not self._paused
+        self._paused = True
+
+    def resume_writing(self) -> None:
+        assert self._paused
+        self._paused = False
+
+        waiter = self._drain_waiter
+        if waiter is not None:
+            self._drain_waiter = None
+            if not waiter.done():
+                waiter.set_result(None)
+
+    def pause_reading(self) -> None:
+        if not self._reading_paused and self.transport is not None:
+            try:
+                self.transport.pause_reading()
+            except (AttributeError, NotImplementedError, RuntimeError):
+                pass
+            self._reading_paused = True
+
+    def resume_reading(self) -> None:
+        if self._reading_paused and self.transport is not None:
+            try:
+                self.transport.resume_reading()
+            except (AttributeError, NotImplementedError, RuntimeError):
+                pass
+            self._reading_paused = False
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        tr = cast(asyncio.Transport, transport)
+        tcp_nodelay(tr, True)
+        self.transport = tr
+
+    def connection_lost(self, exc: Optional[BaseException]) -> None:
+        # Wake up the writer if currently paused.
+        self.transport = None
+        if not self._paused:
+            return
+        waiter = self._drain_waiter
+        if waiter is None:
+            return
+        self._drain_waiter = None
+        if waiter.done():
+            return
+        if exc is None:
+            waiter.set_result(None)
+        else:
+            set_exception(
+                waiter,
+                ConnectionError("Connection lost"),
+                exc,
+            )
+
+    async def _drain_helper(self) -> None:
+        if not self.connected:
+            raise ConnectionResetError("Connection lost")
+        if not self._paused:
+            return
+        waiter = self._drain_waiter
+        if waiter is None:
+            waiter = self._loop.create_future()
+            self._drain_waiter = waiter
+        await asyncio.shield(waiter)

env-llmeval/lib/python3.10/site-packages/aiohttp/client.py

@@ -0,0 +1,1363 @@
+"""HTTP Client for asyncio."""
+
+import asyncio
+import base64
+import hashlib
+import json
+import os
+import sys
+import traceback
+import warnings
+from contextlib import suppress
+from types import SimpleNamespace, TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Final,
+    FrozenSet,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+import attr
+from multidict import CIMultiDict, MultiDict, MultiDictProxy, istr
+from yarl import URL
+
+from . import hdrs, http, payload
+from .abc import AbstractCookieJar
+from .client_exceptions import (
+    ClientConnectionError as ClientConnectionError,
+    ClientConnectorCertificateError as ClientConnectorCertificateError,
+    ClientConnectorError as ClientConnectorError,
+    ClientConnectorSSLError as ClientConnectorSSLError,
+    ClientError as ClientError,
+    ClientHttpProxyError as ClientHttpProxyError,
+    ClientOSError as ClientOSError,
+    ClientPayloadError as ClientPayloadError,
+    ClientProxyConnectionError as ClientProxyConnectionError,
+    ClientResponseError as ClientResponseError,
+    ClientSSLError as ClientSSLError,
+    ContentTypeError as ContentTypeError,
+    InvalidURL as InvalidURL,
+    ServerConnectionError as ServerConnectionError,
+    ServerDisconnectedError as ServerDisconnectedError,
+    ServerFingerprintMismatch as ServerFingerprintMismatch,
+    ServerTimeoutError as ServerTimeoutError,
+    TooManyRedirects as TooManyRedirects,
+    WSServerHandshakeError as WSServerHandshakeError,
+)
+from .client_reqrep import (
+    ClientRequest as ClientRequest,
+    ClientResponse as ClientResponse,
+    Fingerprint as Fingerprint,
+    RequestInfo as RequestInfo,
+    _merge_ssl_params,
+)
+from .client_ws import ClientWebSocketResponse as ClientWebSocketResponse
+from .connector import (
+    BaseConnector as BaseConnector,
+    NamedPipeConnector as NamedPipeConnector,
+    TCPConnector as TCPConnector,
+    UnixConnector as UnixConnector,
+)
+from .cookiejar import CookieJar
+from .helpers import (
+    _SENTINEL,
+    DEBUG,
+    BasicAuth,
+    TimeoutHandle,
+    ceil_timeout,
+    get_env_proxy_for_url,
+    get_running_loop,
+    method_must_be_empty_body,
+    sentinel,
+    strip_auth_from_url,
+)
+from .http import WS_KEY, HttpVersion, WebSocketReader, WebSocketWriter
+from .http_websocket import WSHandshakeError, WSMessage, ws_ext_gen, ws_ext_parse
+from .streams import FlowControlDataQueue
+from .tracing import Trace, TraceConfig
+from .typedefs import JSONEncoder, LooseCookies, LooseHeaders, StrOrURL
+
+__all__ = (
+    # client_exceptions
+    "ClientConnectionError",
+    "ClientConnectorCertificateError",
+    "ClientConnectorError",
+    "ClientConnectorSSLError",
+    "ClientError",
+    "ClientHttpProxyError",
+    "ClientOSError",
+    "ClientPayloadError",
+    "ClientProxyConnectionError",
+    "ClientResponseError",
+    "ClientSSLError",
+    "ContentTypeError",
+    "InvalidURL",
+    "ServerConnectionError",
+    "ServerDisconnectedError",
+    "ServerFingerprintMismatch",
+    "ServerTimeoutError",
+    "TooManyRedirects",
+    "WSServerHandshakeError",
+    # client_reqrep
+    "ClientRequest",
+    "ClientResponse",
+    "Fingerprint",
+    "RequestInfo",
+    # connector
+    "BaseConnector",
+    "TCPConnector",
+    "UnixConnector",
+    "NamedPipeConnector",
+    # client_ws
+    "ClientWebSocketResponse",
+    # client
+    "ClientSession",
+    "ClientTimeout",
+    "request",
+)
+
+
+if TYPE_CHECKING:
+    from ssl import SSLContext
+else:
+    SSLContext = None
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class ClientTimeout:
+    total: Optional[float] = None
+    connect: Optional[float] = None
+    sock_read: Optional[float] = None
+    sock_connect: Optional[float] = None
+    ceil_threshold: float = 5
+
+    # pool_queue_timeout: Optional[float] = None
+    # dns_resolution_timeout: Optional[float] = None
+    # socket_connect_timeout: Optional[float] = None
+    # connection_acquiring_timeout: Optional[float] = None
+    # new_connection_timeout: Optional[float] = None
+    # http_header_timeout: Optional[float] = None
+    # response_body_timeout: Optional[float] = None
+
+    # to create a timeout specific for a single request, either
+    # - create a completely new one to overwrite the default
+    # - or use http://www.attrs.org/en/stable/api.html#attr.evolve
+    # to overwrite the defaults
+
+
+# 5 Minute default read timeout
+DEFAULT_TIMEOUT: Final[ClientTimeout] = ClientTimeout(total=5 * 60)
+
+_RetType = TypeVar("_RetType")
+_CharsetResolver = Callable[[ClientResponse, bytes], str]
+
+
+class ClientSession:
+    """First-class interface for making HTTP requests."""
+
+    ATTRS = frozenset(
+        [
+            "_base_url",
+            "_source_traceback",
+            "_connector",
+            "requote_redirect_url",
+            "_loop",
+            "_cookie_jar",
+            "_connector_owner",
+            "_default_auth",
+            "_version",
+            "_json_serialize",
+            "_requote_redirect_url",
+            "_timeout",
+            "_raise_for_status",
+            "_auto_decompress",
+            "_trust_env",
+            "_default_headers",
+            "_skip_auto_headers",
+            "_request_class",
+            "_response_class",
+            "_ws_response_class",
+            "_trace_configs",
+            "_read_bufsize",
+            "_max_line_size",
+            "_max_field_size",
+            "_resolve_charset",
+        ]
+    )
+
+    _source_traceback: Optional[traceback.StackSummary] = None
+    _connector: Optional[BaseConnector] = None
+
+    def __init__(
+        self,
+        base_url: Optional[StrOrURL] = None,
+        *,
+        connector: Optional[BaseConnector] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        cookies: Optional[LooseCookies] = None,
+        headers: Optional[LooseHeaders] = None,
+        skip_auto_headers: Optional[Iterable[str]] = None,
+        auth: Optional[BasicAuth] = None,
+        json_serialize: JSONEncoder = json.dumps,
+        request_class: Type[ClientRequest] = ClientRequest,
+        response_class: Type[ClientResponse] = ClientResponse,
+        ws_response_class: Type[ClientWebSocketResponse] = ClientWebSocketResponse,
+        version: HttpVersion = http.HttpVersion11,
+        cookie_jar: Optional[AbstractCookieJar] = None,
+        connector_owner: bool = True,
+        raise_for_status: Union[
+            bool, Callable[[ClientResponse], Awaitable[None]]
+        ] = False,
+        read_timeout: Union[float, _SENTINEL] = sentinel,
+        conn_timeout: Optional[float] = None,
+        timeout: Union[object, ClientTimeout] = sentinel,
+        auto_decompress: bool = True,
+        trust_env: bool = False,
+        requote_redirect_url: bool = True,
+        trace_configs: Optional[List[TraceConfig]] = None,
+        read_bufsize: int = 2**16,
+        max_line_size: int = 8190,
+        max_field_size: int = 8190,
+        fallback_charset_resolver: _CharsetResolver = lambda r, b: "utf-8",
+    ) -> None:
+        if loop is None:
+            if connector is not None:
+                loop = connector._loop
+
+        loop = get_running_loop(loop)
+
+        if base_url is None or isinstance(base_url, URL):
+            self._base_url: Optional[URL] = base_url
+        else:
+            self._base_url = URL(base_url)
+            assert (
+                self._base_url.origin() == self._base_url
+            ), "Only absolute URLs without path part are supported"
+
+        if connector is None:
+            connector = TCPConnector(loop=loop)
+
+        if connector._loop is not loop:
+            raise RuntimeError("Session and connector has to use same event loop")
+
+        self._loop = loop
+
+        if loop.get_debug():
+            self._source_traceback = traceback.extract_stack(sys._getframe(1))
+
+        if cookie_jar is None:
+            cookie_jar = CookieJar(loop=loop)
+        self._cookie_jar = cookie_jar
+
+        if cookies is not None:
+            self._cookie_jar.update_cookies(cookies)
+
+        self._connector = connector
+        self._connector_owner = connector_owner
+        self._default_auth = auth
+        self._version = version
+        self._json_serialize = json_serialize
+        if timeout is sentinel or timeout is None:
+            self._timeout = DEFAULT_TIMEOUT
+            if read_timeout is not sentinel:
+                warnings.warn(
+                    "read_timeout is deprecated, " "use timeout argument instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                self._timeout = attr.evolve(self._timeout, total=read_timeout)
+            if conn_timeout is not None:
+                self._timeout = attr.evolve(self._timeout, connect=conn_timeout)
+                warnings.warn(
+                    "conn_timeout is deprecated, " "use timeout argument instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+        else:
+            if not isinstance(timeout, ClientTimeout):
+                raise ValueError(
+                    f"timeout parameter cannot be of {type(timeout)} type, "
+                    "please use 'timeout=ClientTimeout(...)'",
+                )
+            self._timeout = timeout
+            if read_timeout is not sentinel:
+                raise ValueError(
+                    "read_timeout and timeout parameters "
+                    "conflict, please setup "
+                    "timeout.read"
+                )
+            if conn_timeout is not None:
+                raise ValueError(
+                    "conn_timeout and timeout parameters "
+                    "conflict, please setup "
+                    "timeout.connect"
+                )
+        self._raise_for_status = raise_for_status
+        self._auto_decompress = auto_decompress
+        self._trust_env = trust_env
+        self._requote_redirect_url = requote_redirect_url
+        self._read_bufsize = read_bufsize
+        self._max_line_size = max_line_size
+        self._max_field_size = max_field_size
+
+        # Convert to list of tuples
+        if headers:
+            real_headers: CIMultiDict[str] = CIMultiDict(headers)
+        else:
+            real_headers = CIMultiDict()
+        self._default_headers: CIMultiDict[str] = real_headers
+        if skip_auto_headers is not None:
+            self._skip_auto_headers = frozenset(istr(i) for i in skip_auto_headers)
+        else:
+            self._skip_auto_headers = frozenset()
+
+        self._request_class = request_class
+        self._response_class = response_class
+        self._ws_response_class = ws_response_class
+
+        self._trace_configs = trace_configs or []
+        for trace_config in self._trace_configs:
+            trace_config.freeze()
+
+        self._resolve_charset = fallback_charset_resolver
+
+    def __init_subclass__(cls: Type["ClientSession"]) -> None:
+        warnings.warn(
+            "Inheritance class {} from ClientSession "
+            "is discouraged".format(cls.__name__),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    if DEBUG:
+
+        def __setattr__(self, name: str, val: Any) -> None:
+            if name not in self.ATTRS:
+                warnings.warn(
+                    "Setting custom ClientSession.{} attribute "
+                    "is discouraged".format(name),
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+            super().__setattr__(name, val)
+
+    def __del__(self, _warnings: Any = warnings) -> None:
+        if not self.closed:
+            kwargs = {"source": self}
+            _warnings.warn(
+                f"Unclosed client session {self!r}", ResourceWarning, **kwargs
+            )
+            context = {"client_session": self, "message": "Unclosed client session"}
+            if self._source_traceback is not None:
+                context["source_traceback"] = self._source_traceback
+            self._loop.call_exception_handler(context)
+
+    def request(
+        self, method: str, url: StrOrURL, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP request."""
+        return _RequestContextManager(self._request(method, url, **kwargs))
+
+    def _build_url(self, str_or_url: StrOrURL) -> URL:
+        url = URL(str_or_url)
+        if self._base_url is None:
+            return url
+        else:
+            assert not url.is_absolute() and url.path.startswith("/")
+            return self._base_url.join(url)
+
+    async def _request(
+        self,
+        method: str,
+        str_or_url: StrOrURL,
+        *,
+        params: Optional[Mapping[str, str]] = None,
+        data: Any = None,
+        json: Any = None,
+        cookies: Optional[LooseCookies] = None,
+        headers: Optional[LooseHeaders] = None,
+        skip_auto_headers: Optional[Iterable[str]] = None,
+        auth: Optional[BasicAuth] = None,
+        allow_redirects: bool = True,
+        max_redirects: int = 10,
+        compress: Optional[str] = None,
+        chunked: Optional[bool] = None,
+        expect100: bool = False,
+        raise_for_status: Union[
+            None, bool, Callable[[ClientResponse], Awaitable[None]]
+        ] = None,
+        read_until_eof: bool = True,
+        proxy: Optional[StrOrURL] = None,
+        proxy_auth: Optional[BasicAuth] = None,
+        timeout: Union[ClientTimeout, _SENTINEL] = sentinel,
+        verify_ssl: Optional[bool] = None,
+        fingerprint: Optional[bytes] = None,
+        ssl_context: Optional[SSLContext] = None,
+        ssl: Union[SSLContext, bool, Fingerprint] = True,
+        server_hostname: Optional[str] = None,
+        proxy_headers: Optional[LooseHeaders] = None,
+        trace_request_ctx: Optional[SimpleNamespace] = None,
+        read_bufsize: Optional[int] = None,
+        auto_decompress: Optional[bool] = None,
+        max_line_size: Optional[int] = None,
+        max_field_size: Optional[int] = None,
+    ) -> ClientResponse:
+
+        # NOTE: timeout clamps existing connect and read timeouts.  We cannot
+        # set the default to None because we need to detect if the user wants
+        # to use the existing timeouts by setting timeout to None.
+
+        if self.closed:
+            raise RuntimeError("Session is closed")
+
+        ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint)
+
+        if data is not None and json is not None:
+            raise ValueError(
+                "data and json parameters can not be used at the same time"
+            )
+        elif json is not None:
+            data = payload.JsonPayload(json, dumps=self._json_serialize)
+
+        if not isinstance(chunked, bool) and chunked is not None:
+            warnings.warn("Chunk size is deprecated #1615", DeprecationWarning)
+
+        redirects = 0
+        history = []
+        version = self._version
+        params = params or {}
+
+        # Merge with default headers and transform to CIMultiDict
+        headers = self._prepare_headers(headers)
+        proxy_headers = self._prepare_headers(proxy_headers)
+
+        try:
+            url = self._build_url(str_or_url)
+        except ValueError as e:
+            raise InvalidURL(str_or_url) from e
+
+        skip_headers = set(self._skip_auto_headers)
+        if skip_auto_headers is not None:
+            for i in skip_auto_headers:
+                skip_headers.add(istr(i))
+
+        if proxy is not None:
+            try:
+                proxy = URL(proxy)
+            except ValueError as e:
+                raise InvalidURL(proxy) from e
+
+        if timeout is sentinel:
+            real_timeout: ClientTimeout = self._timeout
+        else:
+            if not isinstance(timeout, ClientTimeout):
+                real_timeout = ClientTimeout(total=timeout)
+            else:
+                real_timeout = timeout
+        # timeout is cumulative for all request operations
+        # (request, redirects, responses, data consuming)
+        tm = TimeoutHandle(
+            self._loop, real_timeout.total, ceil_threshold=real_timeout.ceil_threshold
+        )
+        handle = tm.start()
+
+        if read_bufsize is None:
+            read_bufsize = self._read_bufsize
+
+        if auto_decompress is None:
+            auto_decompress = self._auto_decompress
+
+        if max_line_size is None:
+            max_line_size = self._max_line_size
+
+        if max_field_size is None:
+            max_field_size = self._max_field_size
+
+        traces = [
+            Trace(
+                self,
+                trace_config,
+                trace_config.trace_config_ctx(trace_request_ctx=trace_request_ctx),
+            )
+            for trace_config in self._trace_configs
+        ]
+
+        for trace in traces:
+            await trace.send_request_start(method, url.update_query(params), headers)
+
+        timer = tm.timer()
+        try:
+            with timer:
+                while True:
+                    url, auth_from_url = strip_auth_from_url(url)
+                    if auth and auth_from_url:
+                        raise ValueError(
+                            "Cannot combine AUTH argument with "
+                            "credentials encoded in URL"
+                        )
+
+                    if auth is None:
+                        auth = auth_from_url
+                    if auth is None:
+                        auth = self._default_auth
+                    # It would be confusing if we support explicit
+                    # Authorization header with auth argument
+                    if (
+                        headers is not None
+                        and auth is not None
+                        and hdrs.AUTHORIZATION in headers
+                    ):
+                        raise ValueError(
+                            "Cannot combine AUTHORIZATION header "
+                            "with AUTH argument or credentials "
+                            "encoded in URL"
+                        )
+
+                    all_cookies = self._cookie_jar.filter_cookies(url)
+
+                    if cookies is not None:
+                        tmp_cookie_jar = CookieJar()
+                        tmp_cookie_jar.update_cookies(cookies)
+                        req_cookies = tmp_cookie_jar.filter_cookies(url)
+                        if req_cookies:
+                            all_cookies.load(req_cookies)
+
+                    if proxy is not None:
+                        proxy = URL(proxy)
+                    elif self._trust_env:
+                        with suppress(LookupError):
+                            proxy, proxy_auth = get_env_proxy_for_url(url)
+
+                    req = self._request_class(
+                        method,
+                        url,
+                        params=params,
+                        headers=headers,
+                        skip_auto_headers=skip_headers,
+                        data=data,
+                        cookies=all_cookies,
+                        auth=auth,
+                        version=version,
+                        compress=compress,
+                        chunked=chunked,
+                        expect100=expect100,
+                        loop=self._loop,
+                        response_class=self._response_class,
+                        proxy=proxy,
+                        proxy_auth=proxy_auth,
+                        timer=timer,
+                        session=self,
+                        ssl=ssl if ssl is not None else True,
+                        server_hostname=server_hostname,
+                        proxy_headers=proxy_headers,
+                        traces=traces,
+                        trust_env=self.trust_env,
+                    )
+
+                    # connection timeout
+                    try:
+                        async with ceil_timeout(
+                            real_timeout.connect,
+                            ceil_threshold=real_timeout.ceil_threshold,
+                        ):
+                            assert self._connector is not None
+                            conn = await self._connector.connect(
+                                req, traces=traces, timeout=real_timeout
+                            )
+                    except asyncio.TimeoutError as exc:
+                        raise ServerTimeoutError(
+                            "Connection timeout " "to host {}".format(url)
+                        ) from exc
+
+                    assert conn.transport is not None
+
+                    assert conn.protocol is not None
+                    conn.protocol.set_response_params(
+                        timer=timer,
+                        skip_payload=method_must_be_empty_body(method),
+                        read_until_eof=read_until_eof,
+                        auto_decompress=auto_decompress,
+                        read_timeout=real_timeout.sock_read,
+                        read_bufsize=read_bufsize,
+                        timeout_ceil_threshold=self._connector._timeout_ceil_threshold,
+                        max_line_size=max_line_size,
+                        max_field_size=max_field_size,
+                    )
+
+                    try:
+                        try:
+                            resp = await req.send(conn)
+                            try:
+                                await resp.start(conn)
+                            except BaseException:
+                                resp.close()
+                                raise
+                        except BaseException:
+                            conn.close()
+                            raise
+                    except ClientError:
+                        raise
+                    except OSError as exc:
+                        if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
+                            raise
+                        raise ClientOSError(*exc.args) from exc
+
+                    self._cookie_jar.update_cookies(resp.cookies, resp.url)
+
+                    # redirects
+                    if resp.status in (301, 302, 303, 307, 308) and allow_redirects:
+
+                        for trace in traces:
+                            await trace.send_request_redirect(
+                                method, url.update_query(params), headers, resp
+                            )
+
+                        redirects += 1
+                        history.append(resp)
+                        if max_redirects and redirects >= max_redirects:
+                            resp.close()
+                            raise TooManyRedirects(
+                                history[0].request_info, tuple(history)
+                            )
+
+                        # For 301 and 302, mimic IE, now changed in RFC
+                        # https://github.com/kennethreitz/requests/pull/269
+                        if (resp.status == 303 and resp.method != hdrs.METH_HEAD) or (
+                            resp.status in (301, 302) and resp.method == hdrs.METH_POST
+                        ):
+                            method = hdrs.METH_GET
+                            data = None
+                            if headers.get(hdrs.CONTENT_LENGTH):
+                                headers.pop(hdrs.CONTENT_LENGTH)
+
+                        r_url = resp.headers.get(hdrs.LOCATION) or resp.headers.get(
+                            hdrs.URI
+                        )
+                        if r_url is None:
+                            # see github.com/aio-libs/aiohttp/issues/2022
+                            break
+                        else:
+                            # reading from correct redirection
+                            # response is forbidden
+                            resp.release()
+
+                        try:
+                            parsed_url = URL(
+                                r_url, encoded=not self._requote_redirect_url
+                            )
+
+                        except ValueError as e:
+                            raise InvalidURL(r_url) from e
+
+                        scheme = parsed_url.scheme
+                        if scheme not in ("http", "https", ""):
+                            resp.close()
+                            raise ValueError("Can redirect only to http or https")
+                        elif not scheme:
+                            parsed_url = url.join(parsed_url)
+
+                        if url.origin() != parsed_url.origin():
+                            auth = None
+                            headers.pop(hdrs.AUTHORIZATION, None)
+
+                        url = parsed_url
+                        params = {}
+                        resp.release()
+                        continue
+
+                    break
+
+            # check response status
+            if raise_for_status is None:
+                raise_for_status = self._raise_for_status
+
+            if raise_for_status is None:
+                pass
+            elif callable(raise_for_status):
+                await raise_for_status(resp)
+            elif raise_for_status:
+                resp.raise_for_status()
+
+            # register connection
+            if handle is not None:
+                if resp.connection is not None:
+                    resp.connection.add_callback(handle.cancel)
+                else:
+                    handle.cancel()
+
+            resp._history = tuple(history)
+
+            for trace in traces:
+                await trace.send_request_end(
+                    method, url.update_query(params), headers, resp
+                )
+            return resp
+
+        except BaseException as e:
+            # cleanup timer
+            tm.close()
+            if handle:
+                handle.cancel()
+                handle = None
+
+            for trace in traces:
+                await trace.send_request_exception(
+                    method, url.update_query(params), headers, e
+                )
+            raise
+
+    def ws_connect(
+        self,
+        url: StrOrURL,
+        *,
+        method: str = hdrs.METH_GET,
+        protocols: Iterable[str] = (),
+        timeout: float = 10.0,
+        receive_timeout: Optional[float] = None,
+        autoclose: bool = True,
+        autoping: bool = True,
+        heartbeat: Optional[float] = None,
+        auth: Optional[BasicAuth] = None,
+        origin: Optional[str] = None,
+        params: Optional[Mapping[str, str]] = None,
+        headers: Optional[LooseHeaders] = None,
+        proxy: Optional[StrOrURL] = None,
+        proxy_auth: Optional[BasicAuth] = None,
+        ssl: Union[SSLContext, bool, None, Fingerprint] = True,
+        verify_ssl: Optional[bool] = None,
+        fingerprint: Optional[bytes] = None,
+        ssl_context: Optional[SSLContext] = None,
+        proxy_headers: Optional[LooseHeaders] = None,
+        compress: int = 0,
+        max_msg_size: int = 4 * 1024 * 1024,
+    ) -> "_WSRequestContextManager":
+        """Initiate websocket connection."""
+        return _WSRequestContextManager(
+            self._ws_connect(
+                url,
+                method=method,
+                protocols=protocols,
+                timeout=timeout,
+                receive_timeout=receive_timeout,
+                autoclose=autoclose,
+                autoping=autoping,
+                heartbeat=heartbeat,
+                auth=auth,
+                origin=origin,
+                params=params,
+                headers=headers,
+                proxy=proxy,
+                proxy_auth=proxy_auth,
+                ssl=ssl,
+                verify_ssl=verify_ssl,
+                fingerprint=fingerprint,
+                ssl_context=ssl_context,
+                proxy_headers=proxy_headers,
+                compress=compress,
+                max_msg_size=max_msg_size,
+            )
+        )
+
+    async def _ws_connect(
+        self,
+        url: StrOrURL,
+        *,
+        method: str = hdrs.METH_GET,
+        protocols: Iterable[str] = (),
+        timeout: float = 10.0,
+        receive_timeout: Optional[float] = None,
+        autoclose: bool = True,
+        autoping: bool = True,
+        heartbeat: Optional[float] = None,
+        auth: Optional[BasicAuth] = None,
+        origin: Optional[str] = None,
+        params: Optional[Mapping[str, str]] = None,
+        headers: Optional[LooseHeaders] = None,
+        proxy: Optional[StrOrURL] = None,
+        proxy_auth: Optional[BasicAuth] = None,
+        ssl: Optional[Union[SSLContext, bool, Fingerprint]] = True,
+        verify_ssl: Optional[bool] = None,
+        fingerprint: Optional[bytes] = None,
+        ssl_context: Optional[SSLContext] = None,
+        proxy_headers: Optional[LooseHeaders] = None,
+        compress: int = 0,
+        max_msg_size: int = 4 * 1024 * 1024,
+    ) -> ClientWebSocketResponse:
+
+        if headers is None:
+            real_headers: CIMultiDict[str] = CIMultiDict()
+        else:
+            real_headers = CIMultiDict(headers)
+
+        default_headers = {
+            hdrs.UPGRADE: "websocket",
+            hdrs.CONNECTION: "Upgrade",
+            hdrs.SEC_WEBSOCKET_VERSION: "13",
+        }
+
+        for key, value in default_headers.items():
+            real_headers.setdefault(key, value)
+
+        sec_key = base64.b64encode(os.urandom(16))
+        real_headers[hdrs.SEC_WEBSOCKET_KEY] = sec_key.decode()
+
+        if protocols:
+            real_headers[hdrs.SEC_WEBSOCKET_PROTOCOL] = ",".join(protocols)
+        if origin is not None:
+            real_headers[hdrs.ORIGIN] = origin
+        if compress:
+            extstr = ws_ext_gen(compress=compress)
+            real_headers[hdrs.SEC_WEBSOCKET_EXTENSIONS] = extstr
+
+        # For the sake of backward compatibility, if user passes in None, convert it to True
+        if ssl is None:
+            ssl = True
+        ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint)
+
+        # send request
+        resp = await self.request(
+            method,
+            url,
+            params=params,
+            headers=real_headers,
+            read_until_eof=False,
+            auth=auth,
+            proxy=proxy,
+            proxy_auth=proxy_auth,
+            ssl=ssl,
+            proxy_headers=proxy_headers,
+        )
+
+        try:
+            # check handshake
+            if resp.status != 101:
+                raise WSServerHandshakeError(
+                    resp.request_info,
+                    resp.history,
+                    message="Invalid response status",
+                    status=resp.status,
+                    headers=resp.headers,
+                )
+
+            if resp.headers.get(hdrs.UPGRADE, "").lower() != "websocket":
+                raise WSServerHandshakeError(
+                    resp.request_info,
+                    resp.history,
+                    message="Invalid upgrade header",
+                    status=resp.status,
+                    headers=resp.headers,
+                )
+
+            if resp.headers.get(hdrs.CONNECTION, "").lower() != "upgrade":
+                raise WSServerHandshakeError(
+                    resp.request_info,
+                    resp.history,
+                    message="Invalid connection header",
+                    status=resp.status,
+                    headers=resp.headers,
+                )
+
+            # key calculation
+            r_key = resp.headers.get(hdrs.SEC_WEBSOCKET_ACCEPT, "")
+            match = base64.b64encode(hashlib.sha1(sec_key + WS_KEY).digest()).decode()
+            if r_key != match:
+                raise WSServerHandshakeError(
+                    resp.request_info,
+                    resp.history,
+                    message="Invalid challenge response",
+                    status=resp.status,
+                    headers=resp.headers,
+                )
+
+            # websocket protocol
+            protocol = None
+            if protocols and hdrs.SEC_WEBSOCKET_PROTOCOL in resp.headers:
+                resp_protocols = [
+                    proto.strip()
+                    for proto in resp.headers[hdrs.SEC_WEBSOCKET_PROTOCOL].split(",")
+                ]
+
+                for proto in resp_protocols:
+                    if proto in protocols:
+                        protocol = proto
+                        break
+
+            # websocket compress
+            notakeover = False
+            if compress:
+                compress_hdrs = resp.headers.get(hdrs.SEC_WEBSOCKET_EXTENSIONS)
+                if compress_hdrs:
+                    try:
+                        compress, notakeover = ws_ext_parse(compress_hdrs)
+                    except WSHandshakeError as exc:
+                        raise WSServerHandshakeError(
+                            resp.request_info,
+                            resp.history,
+                            message=exc.args[0],
+                            status=resp.status,
+                            headers=resp.headers,
+                        ) from exc
+                else:
+                    compress = 0
+                    notakeover = False
+
+            conn = resp.connection
+            assert conn is not None
+            conn_proto = conn.protocol
+            assert conn_proto is not None
+            transport = conn.transport
+            assert transport is not None
+            reader: FlowControlDataQueue[WSMessage] = FlowControlDataQueue(
+                conn_proto, 2**16, loop=self._loop
+            )
+            conn_proto.set_parser(WebSocketReader(reader, max_msg_size), reader)
+            writer = WebSocketWriter(
+                conn_proto,
+                transport,
+                use_mask=True,
+                compress=compress,
+                notakeover=notakeover,
+            )
+        except BaseException:
+            resp.close()
+            raise
+        else:
+            return self._ws_response_class(
+                reader,
+                writer,
+                protocol,
+                resp,
+                timeout,
+                autoclose,
+                autoping,
+                self._loop,
+                receive_timeout=receive_timeout,
+                heartbeat=heartbeat,
+                compress=compress,
+                client_notakeover=notakeover,
+            )
+
+    def _prepare_headers(self, headers: Optional[LooseHeaders]) -> "CIMultiDict[str]":
+        """Add default headers and transform it to CIMultiDict"""
+        # Convert headers to MultiDict
+        result = CIMultiDict(self._default_headers)
+        if headers:
+            if not isinstance(headers, (MultiDictProxy, MultiDict)):
+                headers = CIMultiDict(headers)
+            added_names: Set[str] = set()
+            for key, value in headers.items():
+                if key in added_names:
+                    result.add(key, value)
+                else:
+                    result[key] = value
+                    added_names.add(key)
+        return result
+
+    def get(
+        self, url: StrOrURL, *, allow_redirects: bool = True, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP GET request."""
+        return _RequestContextManager(
+            self._request(hdrs.METH_GET, url, allow_redirects=allow_redirects, **kwargs)
+        )
+
+    def options(
+        self, url: StrOrURL, *, allow_redirects: bool = True, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP OPTIONS request."""
+        return _RequestContextManager(
+            self._request(
+                hdrs.METH_OPTIONS, url, allow_redirects=allow_redirects, **kwargs
+            )
+        )
+
+    def head(
+        self, url: StrOrURL, *, allow_redirects: bool = False, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP HEAD request."""
+        return _RequestContextManager(
+            self._request(
+                hdrs.METH_HEAD, url, allow_redirects=allow_redirects, **kwargs
+            )
+        )
+
+    def post(
+        self, url: StrOrURL, *, data: Any = None, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP POST request."""
+        return _RequestContextManager(
+            self._request(hdrs.METH_POST, url, data=data, **kwargs)
+        )
+
+    def put(
+        self, url: StrOrURL, *, data: Any = None, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP PUT request."""
+        return _RequestContextManager(
+            self._request(hdrs.METH_PUT, url, data=data, **kwargs)
+        )
+
+    def patch(
+        self, url: StrOrURL, *, data: Any = None, **kwargs: Any
+    ) -> "_RequestContextManager":
+        """Perform HTTP PATCH request."""
+        return _RequestContextManager(
+            self._request(hdrs.METH_PATCH, url, data=data, **kwargs)
+        )
+
+    def delete(self, url: StrOrURL, **kwargs: Any) -> "_RequestContextManager":
+        """Perform HTTP DELETE request."""
+        return _RequestContextManager(self._request(hdrs.METH_DELETE, url, **kwargs))
+
+    async def close(self) -> None:
+        """Close underlying connector.
+
+        Release all acquired resources.
+        """
+        if not self.closed:
+            if self._connector is not None and self._connector_owner:
+                await self._connector.close()
+            self._connector = None
+
+    @property
+    def closed(self) -> bool:
+        """Is client session closed.
+
+        A readonly property.
+        """
+        return self._connector is None or self._connector.closed
+
+    @property
+    def connector(self) -> Optional[BaseConnector]:
+        """Connector instance used for the session."""
+        return self._connector
+
+    @property
+    def cookie_jar(self) -> AbstractCookieJar:
+        """The session cookies."""
+        return self._cookie_jar
+
+    @property
+    def version(self) -> Tuple[int, int]:
+        """The session HTTP protocol version."""
+        return self._version
+
+    @property
+    def requote_redirect_url(self) -> bool:
+        """Do URL requoting on redirection handling."""
+        return self._requote_redirect_url
+
+    @requote_redirect_url.setter
+    def requote_redirect_url(self, val: bool) -> None:
+        """Do URL requoting on redirection handling."""
+        warnings.warn(
+            "session.requote_redirect_url modification " "is deprecated #2778",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._requote_redirect_url = val
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop:
+        """Session's loop."""
+        warnings.warn(
+            "client.loop property is deprecated", DeprecationWarning, stacklevel=2
+        )
+        return self._loop
+
+    @property
+    def timeout(self) -> ClientTimeout:
+        """Timeout for the session."""
+        return self._timeout
+
+    @property
+    def headers(self) -> "CIMultiDict[str]":
+        """The default headers of the client session."""
+        return self._default_headers
+
+    @property
+    def skip_auto_headers(self) -> FrozenSet[istr]:
+        """Headers for which autogeneration should be skipped"""
+        return self._skip_auto_headers
+
+    @property
+    def auth(self) -> Optional[BasicAuth]:
+        """An object that represents HTTP Basic Authorization"""
+        return self._default_auth
+
+    @property
+    def json_serialize(self) -> JSONEncoder:
+        """Json serializer callable"""
+        return self._json_serialize
+
+    @property
+    def connector_owner(self) -> bool:
+        """Should connector be closed on session closing"""
+        return self._connector_owner
+
+    @property
+    def raise_for_status(
+        self,
+    ) -> Union[bool, Callable[[ClientResponse], Awaitable[None]]]:
+        """Should `ClientResponse.raise_for_status()` be called for each response."""
+        return self._raise_for_status
+
+    @property
+    def auto_decompress(self) -> bool:
+        """Should the body response be automatically decompressed."""
+        return self._auto_decompress
+
+    @property
+    def trust_env(self) -> bool:
+        """
+        Should proxies information from environment or netrc be trusted.
+
+        Information is from HTTP_PROXY / HTTPS_PROXY environment variables
+        or ~/.netrc file if present.
+        """
+        return self._trust_env
+
+    @property
+    def trace_configs(self) -> List[TraceConfig]:
+        """A list of TraceConfig instances used for client tracing"""
+        return self._trace_configs
+
+    def detach(self) -> None:
+        """Detach connector from session without closing the former.
+
+        Session is switched to closed state anyway.
+        """
+        self._connector = None
+
+    def __enter__(self) -> None:
+        raise TypeError("Use async with instead")
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        # __exit__ should exist in pair with __enter__ but never executed
+        pass  # pragma: no cover
+
+    async def __aenter__(self) -> "ClientSession":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+
+class _BaseRequestContextManager(Coroutine[Any, Any, _RetType], Generic[_RetType]):
+
+    __slots__ = ("_coro", "_resp")
+
+    def __init__(self, coro: Coroutine["asyncio.Future[Any]", None, _RetType]) -> None:
+        self._coro = coro
+
+    def send(self, arg: None) -> "asyncio.Future[Any]":
+        return self._coro.send(arg)
+
+    def throw(self, *args: Any, **kwargs: Any) -> "asyncio.Future[Any]":
+        return self._coro.throw(*args, **kwargs)
+
+    def close(self) -> None:
+        return self._coro.close()
+
+    def __await__(self) -> Generator[Any, None, _RetType]:
+        ret = self._coro.__await__()
+        return ret
+
+    def __iter__(self) -> Generator[Any, None, _RetType]:
+        return self.__await__()
+
+    async def __aenter__(self) -> _RetType:
+        self._resp = await self._coro
+        return self._resp
+
+
+class _RequestContextManager(_BaseRequestContextManager[ClientResponse]):
+    __slots__ = ()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        # We're basing behavior on the exception as it can be caused by
+        # user code unrelated to the status of the connection.  If you
+        # would like to close a connection you must do that
+        # explicitly.  Otherwise connection error handling should kick in
+        # and close/recycle the connection as required.
+        self._resp.release()
+        await self._resp.wait_for_close()
+
+
+class _WSRequestContextManager(_BaseRequestContextManager[ClientWebSocketResponse]):
+    __slots__ = ()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        await self._resp.close()
+
+
+class _SessionRequestContextManager:
+
+    __slots__ = ("_coro", "_resp", "_session")
+
+    def __init__(
+        self,
+        coro: Coroutine["asyncio.Future[Any]", None, ClientResponse],
+        session: ClientSession,
+    ) -> None:
+        self._coro = coro
+        self._resp: Optional[ClientResponse] = None
+        self._session = session
+
+    async def __aenter__(self) -> ClientResponse:
+        try:
+            self._resp = await self._coro
+        except BaseException:
+            await self._session.close()
+            raise
+        else:
+            return self._resp
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        assert self._resp is not None
+        self._resp.close()
+        await self._session.close()
+
+
+def request(
+    method: str,
+    url: StrOrURL,
+    *,
+    params: Optional[Mapping[str, str]] = None,
+    data: Any = None,
+    json: Any = None,
+    headers: Optional[LooseHeaders] = None,
+    skip_auto_headers: Optional[Iterable[str]] = None,
+    auth: Optional[BasicAuth] = None,
+    allow_redirects: bool = True,
+    max_redirects: int = 10,
+    compress: Optional[str] = None,
+    chunked: Optional[bool] = None,
+    expect100: bool = False,
+    raise_for_status: Optional[bool] = None,
+    read_until_eof: bool = True,
+    proxy: Optional[StrOrURL] = None,
+    proxy_auth: Optional[BasicAuth] = None,
+    timeout: Union[ClientTimeout, object] = sentinel,
+    cookies: Optional[LooseCookies] = None,
+    version: HttpVersion = http.HttpVersion11,
+    connector: Optional[BaseConnector] = None,
+    read_bufsize: Optional[int] = None,
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+    max_line_size: int = 8190,
+    max_field_size: int = 8190,
+) -> _SessionRequestContextManager:
+    """Constructs and sends a request.
+
+    Returns response object.
+    method - HTTP method
+    url - request url
+    params - (optional) Dictionary or bytes to be sent in the query
+      string of the new request
+    data - (optional) Dictionary, bytes, or file-like object to
+      send in the body of the request
+    json - (optional) Any json compatible python object
+    headers - (optional) Dictionary of HTTP Headers to send with
+      the request
+    cookies - (optional) Dict object to send with the request
+    auth - (optional) BasicAuth named tuple represent HTTP Basic Auth
+    auth - aiohttp.helpers.BasicAuth
+    allow_redirects - (optional) If set to False, do not follow
+      redirects
+    version - Request HTTP version.
+    compress - Set to True if request has to be compressed
+       with deflate encoding.
+    chunked - Set to chunk size for chunked transfer encoding.
+    expect100 - Expect 100-continue response from server.
+    connector - BaseConnector sub-class instance to support
+       connection pooling.
+    read_until_eof - Read response until eof if response
+       does not have Content-Length header.
+    loop - Optional event loop.
+    timeout - Optional ClientTimeout settings structure, 5min
+       total timeout by default.
+    Usage::
+      >>> import aiohttp
+      >>> resp = await aiohttp.request('GET', 'http://python.org/')
+      >>> resp
+      <ClientResponse(python.org/) [200]>
+      >>> data = await resp.read()
+    """
+    connector_owner = False
+    if connector is None:
+        connector_owner = True
+        connector = TCPConnector(loop=loop, force_close=True)
+
+    session = ClientSession(
+        loop=loop,
+        cookies=cookies,
+        version=version,
+        timeout=timeout,
+        connector=connector,
+        connector_owner=connector_owner,
+    )
+
+    return _SessionRequestContextManager(
+        session._request(
+            method,
+            url,
+            params=params,
+            data=data,
+            json=json,
+            headers=headers,
+            skip_auto_headers=skip_auto_headers,
+            auth=auth,
+            allow_redirects=allow_redirects,
+            max_redirects=max_redirects,
+            compress=compress,
+            chunked=chunked,
+            expect100=expect100,
+            raise_for_status=raise_for_status,
+            read_until_eof=read_until_eof,
+            proxy=proxy,
+            proxy_auth=proxy_auth,
+            read_bufsize=read_bufsize,
+            max_line_size=max_line_size,
+            max_field_size=max_field_size,
+        ),
+        session,
+    )

env-llmeval/lib/python3.10/site-packages/aiohttp/client_exceptions.py

@@ -0,0 +1,346 @@
+"""HTTP related errors."""
+
+import asyncio
+import warnings
+from typing import TYPE_CHECKING, Any, Optional, Tuple, Union
+
+from .http_parser import RawResponseMessage
+from .typedefs import LooseHeaders
+
+try:
+    import ssl
+
+    SSLContext = ssl.SSLContext
+except ImportError:  # pragma: no cover
+    ssl = SSLContext = None  # type: ignore[assignment]
+
+
+if TYPE_CHECKING:
+    from .client_reqrep import ClientResponse, ConnectionKey, Fingerprint, RequestInfo
+else:
+    RequestInfo = ClientResponse = ConnectionKey = None
+
+__all__ = (
+    "ClientError",
+    "ClientConnectionError",
+    "ClientOSError",
+    "ClientConnectorError",
+    "ClientProxyConnectionError",
+    "ClientSSLError",
+    "ClientConnectorSSLError",
+    "ClientConnectorCertificateError",
+    "ServerConnectionError",
+    "ServerTimeoutError",
+    "ServerDisconnectedError",
+    "ServerFingerprintMismatch",
+    "ClientResponseError",
+    "ClientHttpProxyError",
+    "WSServerHandshakeError",
+    "ContentTypeError",
+    "ClientPayloadError",
+    "InvalidURL",
+)
+
+
+class ClientError(Exception):
+    """Base class for client connection errors."""
+
+
+class ClientResponseError(ClientError):
+    """Base class for exceptions that occur after getting a response.
+
+    request_info: An instance of RequestInfo.
+    history: A sequence of responses, if redirects occurred.
+    status: HTTP status code.
+    message: Error message.
+    headers: Response headers.
+    """
+
+    def __init__(
+        self,
+        request_info: RequestInfo,
+        history: Tuple[ClientResponse, ...],
+        *,
+        code: Optional[int] = None,
+        status: Optional[int] = None,
+        message: str = "",
+        headers: Optional[LooseHeaders] = None,
+    ) -> None:
+        self.request_info = request_info
+        if code is not None:
+            if status is not None:
+                raise ValueError(
+                    "Both code and status arguments are provided; "
+                    "code is deprecated, use status instead"
+                )
+            warnings.warn(
+                "code argument is deprecated, use status instead",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if status is not None:
+            self.status = status
+        elif code is not None:
+            self.status = code
+        else:
+            self.status = 0
+        self.message = message
+        self.headers = headers
+        self.history = history
+        self.args = (request_info, history)
+
+    def __str__(self) -> str:
+        return "{}, message={!r}, url={!r}".format(
+            self.status,
+            self.message,
+            self.request_info.real_url,
+        )
+
+    def __repr__(self) -> str:
+        args = f"{self.request_info!r}, {self.history!r}"
+        if self.status != 0:
+            args += f", status={self.status!r}"
+        if self.message != "":
+            args += f", message={self.message!r}"
+        if self.headers is not None:
+            args += f", headers={self.headers!r}"
+        return f"{type(self).__name__}({args})"
+
+    @property
+    def code(self) -> int:
+        warnings.warn(
+            "code property is deprecated, use status instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.status
+
+    @code.setter
+    def code(self, value: int) -> None:
+        warnings.warn(
+            "code property is deprecated, use status instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.status = value
+
+
+class ContentTypeError(ClientResponseError):
+    """ContentType found is not valid."""
+
+
+class WSServerHandshakeError(ClientResponseError):
+    """websocket server handshake error."""
+
+
+class ClientHttpProxyError(ClientResponseError):
+    """HTTP proxy error.
+
+    Raised in :class:`aiohttp.connector.TCPConnector` if
+    proxy responds with status other than ``200 OK``
+    on ``CONNECT`` request.
+    """
+
+
+class TooManyRedirects(ClientResponseError):
+    """Client was redirected too many times."""
+
+
+class ClientConnectionError(ClientError):
+    """Base class for client socket errors."""
+
+
+class ClientOSError(ClientConnectionError, OSError):
+    """OSError error."""
+
+
+class ClientConnectorError(ClientOSError):
+    """Client connector error.
+
+    Raised in :class:`aiohttp.connector.TCPConnector` if
+        a connection can not be established.
+    """
+
+    def __init__(self, connection_key: ConnectionKey, os_error: OSError) -> None:
+        self._conn_key = connection_key
+        self._os_error = os_error
+        super().__init__(os_error.errno, os_error.strerror)
+        self.args = (connection_key, os_error)
+
+    @property
+    def os_error(self) -> OSError:
+        return self._os_error
+
+    @property
+    def host(self) -> str:
+        return self._conn_key.host
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._conn_key.port
+
+    @property
+    def ssl(self) -> Union[SSLContext, bool, "Fingerprint"]:
+        return self._conn_key.ssl
+
+    def __str__(self) -> str:
+        return "Cannot connect to host {0.host}:{0.port} ssl:{1} [{2}]".format(
+            self, "default" if self.ssl is True else self.ssl, self.strerror
+        )
+
+    # OSError.__reduce__ does too much black magick
+    __reduce__ = BaseException.__reduce__
+
+
+class ClientProxyConnectionError(ClientConnectorError):
+    """Proxy connection error.
+
+    Raised in :class:`aiohttp.connector.TCPConnector` if
+        connection to proxy can not be established.
+    """
+
+
+class UnixClientConnectorError(ClientConnectorError):
+    """Unix connector error.
+
+    Raised in :py:class:`aiohttp.connector.UnixConnector`
+    if connection to unix socket can not be established.
+    """
+
+    def __init__(
+        self, path: str, connection_key: ConnectionKey, os_error: OSError
+    ) -> None:
+        self._path = path
+        super().__init__(connection_key, os_error)
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    def __str__(self) -> str:
+        return "Cannot connect to unix socket {0.path} ssl:{1} [{2}]".format(
+            self, "default" if self.ssl is True else self.ssl, self.strerror
+        )
+
+
+class ServerConnectionError(ClientConnectionError):
+    """Server connection errors."""
+
+
+class ServerDisconnectedError(ServerConnectionError):
+    """Server disconnected."""
+
+    def __init__(self, message: Union[RawResponseMessage, str, None] = None) -> None:
+        if message is None:
+            message = "Server disconnected"
+
+        self.args = (message,)
+        self.message = message
+
+
+class ServerTimeoutError(ServerConnectionError, asyncio.TimeoutError):
+    """Server timeout error."""
+
+
+class ServerFingerprintMismatch(ServerConnectionError):
+    """SSL certificate does not match expected fingerprint."""
+
+    def __init__(self, expected: bytes, got: bytes, host: str, port: int) -> None:
+        self.expected = expected
+        self.got = got
+        self.host = host
+        self.port = port
+        self.args = (expected, got, host, port)
+
+    def __repr__(self) -> str:
+        return "<{} expected={!r} got={!r} host={!r} port={!r}>".format(
+            self.__class__.__name__, self.expected, self.got, self.host, self.port
+        )
+
+
+class ClientPayloadError(ClientError):
+    """Response payload error."""
+
+
+class InvalidURL(ClientError, ValueError):
+    """Invalid URL.
+
+    URL used for fetching is malformed, e.g. it doesn't contains host
+    part.
+    """
+
+    # Derive from ValueError for backward compatibility
+
+    def __init__(self, url: Any) -> None:
+        # The type of url is not yarl.URL because the exception can be raised
+        # on URL(url) call
+        super().__init__(url)
+
+    @property
+    def url(self) -> Any:
+        return self.args[0]
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.url}>"
+
+
+class ClientSSLError(ClientConnectorError):
+    """Base error for ssl.*Errors."""
+
+
+if ssl is not None:
+    cert_errors = (ssl.CertificateError,)
+    cert_errors_bases = (
+        ClientSSLError,
+        ssl.CertificateError,
+    )
+
+    ssl_errors = (ssl.SSLError,)
+    ssl_error_bases = (ClientSSLError, ssl.SSLError)
+else:  # pragma: no cover
+    cert_errors = tuple()
+    cert_errors_bases = (
+        ClientSSLError,
+        ValueError,
+    )
+
+    ssl_errors = tuple()
+    ssl_error_bases = (ClientSSLError,)
+
+
+class ClientConnectorSSLError(*ssl_error_bases):  # type: ignore[misc]
+    """Response ssl error."""
+
+
+class ClientConnectorCertificateError(*cert_errors_bases):  # type: ignore[misc]
+    """Response certificate error."""
+
+    def __init__(
+        self, connection_key: ConnectionKey, certificate_error: Exception
+    ) -> None:
+        self._conn_key = connection_key
+        self._certificate_error = certificate_error
+        self.args = (connection_key, certificate_error)
+
+    @property
+    def certificate_error(self) -> Exception:
+        return self._certificate_error
+
+    @property
+    def host(self) -> str:
+        return self._conn_key.host
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._conn_key.port
+
+    @property
+    def ssl(self) -> bool:
+        return self._conn_key.is_ssl
+
+    def __str__(self) -> str:
+        return (
+            "Cannot connect to host {0.host}:{0.port} ssl:{0.ssl} "
+            "[{0.certificate_error.__class__.__name__}: "
+            "{0.certificate_error.args}]".format(self)
+        )

env-llmeval/lib/python3.10/site-packages/aiohttp/client_proto.py

@@ -0,0 +1,296 @@
+import asyncio
+from contextlib import suppress
+from typing import Any, Optional, Tuple
+
+from .base_protocol import BaseProtocol
+from .client_exceptions import (
+    ClientOSError,
+    ClientPayloadError,
+    ServerDisconnectedError,
+    ServerTimeoutError,
+)
+from .helpers import (
+    _EXC_SENTINEL,
+    BaseTimerContext,
+    set_exception,
+    status_code_must_be_empty_body,
+)
+from .http import HttpResponseParser, RawResponseMessage
+from .http_exceptions import HttpProcessingError
+from .streams import EMPTY_PAYLOAD, DataQueue, StreamReader
+
+
+class ResponseHandler(BaseProtocol, DataQueue[Tuple[RawResponseMessage, StreamReader]]):
+    """Helper class to adapt between Protocol and StreamReader."""
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        BaseProtocol.__init__(self, loop=loop)
+        DataQueue.__init__(self, loop)
+
+        self._should_close = False
+
+        self._payload: Optional[StreamReader] = None
+        self._skip_payload = False
+        self._payload_parser = None
+
+        self._timer = None
+
+        self._tail = b""
+        self._upgraded = False
+        self._parser: Optional[HttpResponseParser] = None
+
+        self._read_timeout: Optional[float] = None
+        self._read_timeout_handle: Optional[asyncio.TimerHandle] = None
+
+        self._timeout_ceil_threshold: Optional[float] = 5
+
+    @property
+    def upgraded(self) -> bool:
+        return self._upgraded
+
+    @property
+    def should_close(self) -> bool:
+        if self._payload is not None and not self._payload.is_eof() or self._upgraded:
+            return True
+
+        return (
+            self._should_close
+            or self._upgraded
+            or self.exception() is not None
+            or self._payload_parser is not None
+            or len(self) > 0
+            or bool(self._tail)
+        )
+
+    def force_close(self) -> None:
+        self._should_close = True
+
+    def close(self) -> None:
+        transport = self.transport
+        if transport is not None:
+            transport.close()
+            self.transport = None
+            self._payload = None
+            self._drop_timeout()
+
+    def is_connected(self) -> bool:
+        return self.transport is not None and not self.transport.is_closing()
+
+    def connection_lost(self, exc: Optional[BaseException]) -> None:
+        self._drop_timeout()
+
+        original_connection_error = exc
+        reraised_exc = original_connection_error
+
+        connection_closed_cleanly = original_connection_error is None
+
+        if self._payload_parser is not None:
+            with suppress(Exception):  # FIXME: log this somehow?
+                self._payload_parser.feed_eof()
+
+        uncompleted = None
+        if self._parser is not None:
+            try:
+                uncompleted = self._parser.feed_eof()
+            except Exception as underlying_exc:
+                if self._payload is not None:
+                    client_payload_exc_msg = (
+                        f"Response payload is not completed: {underlying_exc !r}"
+                    )
+                    if not connection_closed_cleanly:
+                        client_payload_exc_msg = (
+                            f"{client_payload_exc_msg !s}. "
+                            f"{original_connection_error !r}"
+                        )
+                    set_exception(
+                        self._payload,
+                        ClientPayloadError(client_payload_exc_msg),
+                        underlying_exc,
+                    )
+
+        if not self.is_eof():
+            if isinstance(original_connection_error, OSError):
+                reraised_exc = ClientOSError(*original_connection_error.args)
+            if connection_closed_cleanly:
+                reraised_exc = ServerDisconnectedError(uncompleted)
+            # assigns self._should_close to True as side effect,
+            # we do it anyway below
+            underlying_non_eof_exc = (
+                _EXC_SENTINEL
+                if connection_closed_cleanly
+                else original_connection_error
+            )
+            assert underlying_non_eof_exc is not None
+            assert reraised_exc is not None
+            self.set_exception(reraised_exc, underlying_non_eof_exc)
+
+        self._should_close = True
+        self._parser = None
+        self._payload = None
+        self._payload_parser = None
+        self._reading_paused = False
+
+        super().connection_lost(reraised_exc)
+
+    def eof_received(self) -> None:
+        # should call parser.feed_eof() most likely
+        self._drop_timeout()
+
+    def pause_reading(self) -> None:
+        super().pause_reading()
+        self._drop_timeout()
+
+    def resume_reading(self) -> None:
+        super().resume_reading()
+        self._reschedule_timeout()
+
+    def set_exception(
+        self,
+        exc: BaseException,
+        exc_cause: BaseException = _EXC_SENTINEL,
+    ) -> None:
+        self._should_close = True
+        self._drop_timeout()
+        super().set_exception(exc, exc_cause)
+
+    def set_parser(self, parser: Any, payload: Any) -> None:
+        # TODO: actual types are:
+        #   parser: WebSocketReader
+        #   payload: FlowControlDataQueue
+        # but they are not generi enough
+        # Need an ABC for both types
+        self._payload = payload
+        self._payload_parser = parser
+
+        self._drop_timeout()
+
+        if self._tail:
+            data, self._tail = self._tail, b""
+            self.data_received(data)
+
+    def set_response_params(
+        self,
+        *,
+        timer: Optional[BaseTimerContext] = None,
+        skip_payload: bool = False,
+        read_until_eof: bool = False,
+        auto_decompress: bool = True,
+        read_timeout: Optional[float] = None,
+        read_bufsize: int = 2**16,
+        timeout_ceil_threshold: float = 5,
+        max_line_size: int = 8190,
+        max_field_size: int = 8190,
+    ) -> None:
+        self._skip_payload = skip_payload
+
+        self._read_timeout = read_timeout
+
+        self._timeout_ceil_threshold = timeout_ceil_threshold
+
+        self._parser = HttpResponseParser(
+            self,
+            self._loop,
+            read_bufsize,
+            timer=timer,
+            payload_exception=ClientPayloadError,
+            response_with_body=not skip_payload,
+            read_until_eof=read_until_eof,
+            auto_decompress=auto_decompress,
+            max_line_size=max_line_size,
+            max_field_size=max_field_size,
+        )
+
+        if self._tail:
+            data, self._tail = self._tail, b""
+            self.data_received(data)
+
+    def _drop_timeout(self) -> None:
+        if self._read_timeout_handle is not None:
+            self._read_timeout_handle.cancel()
+            self._read_timeout_handle = None
+
+    def _reschedule_timeout(self) -> None:
+        timeout = self._read_timeout
+        if self._read_timeout_handle is not None:
+            self._read_timeout_handle.cancel()
+
+        if timeout:
+            self._read_timeout_handle = self._loop.call_later(
+                timeout, self._on_read_timeout
+            )
+        else:
+            self._read_timeout_handle = None
+
+    def start_timeout(self) -> None:
+        self._reschedule_timeout()
+
+    def _on_read_timeout(self) -> None:
+        exc = ServerTimeoutError("Timeout on reading data from socket")
+        self.set_exception(exc)
+        if self._payload is not None:
+            set_exception(self._payload, exc)
+
+    def data_received(self, data: bytes) -> None:
+        self._reschedule_timeout()
+
+        if not data:
+            return
+
+        # custom payload parser
+        if self._payload_parser is not None:
+            eof, tail = self._payload_parser.feed_data(data)
+            if eof:
+                self._payload = None
+                self._payload_parser = None
+
+                if tail:
+                    self.data_received(tail)
+            return
+        else:
+            if self._upgraded or self._parser is None:
+                # i.e. websocket connection, websocket parser is not set yet
+                self._tail += data
+            else:
+                # parse http messages
+                try:
+                    messages, upgraded, tail = self._parser.feed_data(data)
+                except BaseException as underlying_exc:
+                    if self.transport is not None:
+                        # connection.release() could be called BEFORE
+                        # data_received(), the transport is already
+                        # closed in this case
+                        self.transport.close()
+                    # should_close is True after the call
+                    self.set_exception(HttpProcessingError(), underlying_exc)
+                    return
+
+                self._upgraded = upgraded
+
+                payload: Optional[StreamReader] = None
+                for message, payload in messages:
+                    if message.should_close:
+                        self._should_close = True
+
+                    self._payload = payload
+
+                    if self._skip_payload or status_code_must_be_empty_body(
+                        message.code
+                    ):
+                        self.feed_data((message, EMPTY_PAYLOAD), 0)
+                    else:
+                        self.feed_data((message, payload), 0)
+                if payload is not None:
+                    # new message(s) was processed
+                    # register timeout handler unsubscribing
+                    # either on end-of-stream or immediately for
+                    # EMPTY_PAYLOAD
+                    if payload is not EMPTY_PAYLOAD:
+                        payload.on_eof(self._drop_timeout)
+                    else:
+                        self._drop_timeout()
+
+                if tail:
+                    if upgraded:
+                        self.data_received(tail)
+                    else:
+                        self._tail = tail

env-llmeval/lib/python3.10/site-packages/aiohttp/client_reqrep.py

@@ -0,0 +1,1207 @@
+import asyncio
+import codecs
+import contextlib
+import functools
+import io
+import re
+import sys
+import traceback
+import warnings
+from hashlib import md5, sha1, sha256
+from http.cookies import CookieError, Morsel, SimpleCookie
+from types import MappingProxyType, TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+import attr
+from multidict import CIMultiDict, CIMultiDictProxy, MultiDict, MultiDictProxy
+from yarl import URL
+
+from . import hdrs, helpers, http, multipart, payload
+from .abc import AbstractStreamWriter
+from .client_exceptions import (
+    ClientConnectionError,
+    ClientOSError,
+    ClientResponseError,
+    ContentTypeError,
+    InvalidURL,
+    ServerFingerprintMismatch,
+)
+from .compression_utils import HAS_BROTLI
+from .formdata import FormData
+from .helpers import (
+    BaseTimerContext,
+    BasicAuth,
+    HeadersMixin,
+    TimerNoop,
+    basicauth_from_netrc,
+    netrc_from_env,
+    noop,
+    reify,
+    set_exception,
+    set_result,
+)
+from .http import (
+    SERVER_SOFTWARE,
+    HttpVersion,
+    HttpVersion10,
+    HttpVersion11,
+    StreamWriter,
+)
+from .log import client_logger
+from .streams import StreamReader
+from .typedefs import (
+    DEFAULT_JSON_DECODER,
+    JSONDecoder,
+    LooseCookies,
+    LooseHeaders,
+    RawHeaders,
+)
+
+try:
+    import ssl
+    from ssl import SSLContext
+except ImportError:  # pragma: no cover
+    ssl = None  # type: ignore[assignment]
+    SSLContext = object  # type: ignore[misc,assignment]
+
+
+__all__ = ("ClientRequest", "ClientResponse", "RequestInfo", "Fingerprint")
+
+
+if TYPE_CHECKING:
+    from .client import ClientSession
+    from .connector import Connection
+    from .tracing import Trace
+
+
+_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]")
+json_re = re.compile(r"^application/(?:[\w.+-]+?\+)?json")
+
+
+def _gen_default_accept_encoding() -> str:
+    return "gzip, deflate, br" if HAS_BROTLI else "gzip, deflate"
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class ContentDisposition:
+    type: Optional[str]
+    parameters: "MappingProxyType[str, str]"
+    filename: Optional[str]
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class RequestInfo:
+    url: URL
+    method: str
+    headers: "CIMultiDictProxy[str]"
+    real_url: URL = attr.ib()
+
+    @real_url.default
+    def real_url_default(self) -> URL:
+        return self.url
+
+
+class Fingerprint:
+    HASHFUNC_BY_DIGESTLEN = {
+        16: md5,
+        20: sha1,
+        32: sha256,
+    }
+
+    def __init__(self, fingerprint: bytes) -> None:
+        digestlen = len(fingerprint)
+        hashfunc = self.HASHFUNC_BY_DIGESTLEN.get(digestlen)
+        if not hashfunc:
+            raise ValueError("fingerprint has invalid length")
+        elif hashfunc is md5 or hashfunc is sha1:
+            raise ValueError(
+                "md5 and sha1 are insecure and " "not supported. Use sha256."
+            )
+        self._hashfunc = hashfunc
+        self._fingerprint = fingerprint
+
+    @property
+    def fingerprint(self) -> bytes:
+        return self._fingerprint
+
+    def check(self, transport: asyncio.Transport) -> None:
+        if not transport.get_extra_info("sslcontext"):
+            return
+        sslobj = transport.get_extra_info("ssl_object")
+        cert = sslobj.getpeercert(binary_form=True)
+        got = self._hashfunc(cert).digest()
+        if got != self._fingerprint:
+            host, port, *_ = transport.get_extra_info("peername")
+            raise ServerFingerprintMismatch(self._fingerprint, got, host, port)
+
+
+if ssl is not None:
+    SSL_ALLOWED_TYPES = (ssl.SSLContext, bool, Fingerprint, type(None))
+else:  # pragma: no cover
+    SSL_ALLOWED_TYPES = (bool, type(None))
+
+
+def _merge_ssl_params(
+    ssl: Union["SSLContext", bool, Fingerprint],
+    verify_ssl: Optional[bool],
+    ssl_context: Optional["SSLContext"],
+    fingerprint: Optional[bytes],
+) -> Union["SSLContext", bool, Fingerprint]:
+    if ssl is None:
+        ssl = True  # Double check for backwards compatibility
+    if verify_ssl is not None and not verify_ssl:
+        warnings.warn(
+            "verify_ssl is deprecated, use ssl=False instead",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+        if ssl is not True:
+            raise ValueError(
+                "verify_ssl, ssl_context, fingerprint and ssl "
+                "parameters are mutually exclusive"
+            )
+        else:
+            ssl = False
+    if ssl_context is not None:
+        warnings.warn(
+            "ssl_context is deprecated, use ssl=context instead",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+        if ssl is not True:
+            raise ValueError(
+                "verify_ssl, ssl_context, fingerprint and ssl "
+                "parameters are mutually exclusive"
+            )
+        else:
+            ssl = ssl_context
+    if fingerprint is not None:
+        warnings.warn(
+            "fingerprint is deprecated, " "use ssl=Fingerprint(fingerprint) instead",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+        if ssl is not True:
+            raise ValueError(
+                "verify_ssl, ssl_context, fingerprint and ssl "
+                "parameters are mutually exclusive"
+            )
+        else:
+            ssl = Fingerprint(fingerprint)
+    if not isinstance(ssl, SSL_ALLOWED_TYPES):
+        raise TypeError(
+            "ssl should be SSLContext, bool, Fingerprint or None, "
+            "got {!r} instead.".format(ssl)
+        )
+    return ssl
+
+
+@attr.s(auto_attribs=True, slots=True, frozen=True)
+class ConnectionKey:
+    # the key should contain an information about used proxy / TLS
+    # to prevent reusing wrong connections from a pool
+    host: str
+    port: Optional[int]
+    is_ssl: bool
+    ssl: Union[SSLContext, bool, Fingerprint]
+    proxy: Optional[URL]
+    proxy_auth: Optional[BasicAuth]
+    proxy_headers_hash: Optional[int]  # hash(CIMultiDict)
+
+
+def _is_expected_content_type(
+    response_content_type: str, expected_content_type: str
+) -> bool:
+    if expected_content_type == "application/json":
+        return json_re.match(response_content_type) is not None
+    return expected_content_type in response_content_type
+
+
+class ClientRequest:
+    GET_METHODS = {
+        hdrs.METH_GET,
+        hdrs.METH_HEAD,
+        hdrs.METH_OPTIONS,
+        hdrs.METH_TRACE,
+    }
+    POST_METHODS = {hdrs.METH_PATCH, hdrs.METH_POST, hdrs.METH_PUT}
+    ALL_METHODS = GET_METHODS.union(POST_METHODS).union({hdrs.METH_DELETE})
+
+    DEFAULT_HEADERS = {
+        hdrs.ACCEPT: "*/*",
+        hdrs.ACCEPT_ENCODING: _gen_default_accept_encoding(),
+    }
+
+    body = b""
+    auth = None
+    response = None
+
+    __writer = None  # async task for streaming data
+    _continue = None  # waiter future for '100 Continue' response
+
+    # N.B.
+    # Adding __del__ method with self._writer closing doesn't make sense
+    # because _writer is instance method, thus it keeps a reference to self.
+    # Until writer has finished finalizer will not be called.
+
+    def __init__(
+        self,
+        method: str,
+        url: URL,
+        *,
+        params: Optional[Mapping[str, str]] = None,
+        headers: Optional[LooseHeaders] = None,
+        skip_auto_headers: Iterable[str] = frozenset(),
+        data: Any = None,
+        cookies: Optional[LooseCookies] = None,
+        auth: Optional[BasicAuth] = None,
+        version: http.HttpVersion = http.HttpVersion11,
+        compress: Optional[str] = None,
+        chunked: Optional[bool] = None,
+        expect100: bool = False,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        response_class: Optional[Type["ClientResponse"]] = None,
+        proxy: Optional[URL] = None,
+        proxy_auth: Optional[BasicAuth] = None,
+        timer: Optional[BaseTimerContext] = None,
+        session: Optional["ClientSession"] = None,
+        ssl: Union[SSLContext, bool, Fingerprint] = True,
+        proxy_headers: Optional[LooseHeaders] = None,
+        traces: Optional[List["Trace"]] = None,
+        trust_env: bool = False,
+        server_hostname: Optional[str] = None,
+    ):
+        if loop is None:
+            loop = asyncio.get_event_loop()
+
+        match = _CONTAINS_CONTROL_CHAR_RE.search(method)
+        if match:
+            raise ValueError(
+                f"Method cannot contain non-token characters {method!r} "
+                "(found at least {match.group()!r})"
+            )
+
+        assert isinstance(url, URL), url
+        assert isinstance(proxy, (URL, type(None))), proxy
+        # FIXME: session is None in tests only, need to fix tests
+        # assert session is not None
+        self._session = cast("ClientSession", session)
+        if params:
+            q = MultiDict(url.query)
+            url2 = url.with_query(params)
+            q.extend(url2.query)
+            url = url.with_query(q)
+        self.original_url = url
+        self.url = url.with_fragment(None)
+        self.method = method.upper()
+        self.chunked = chunked
+        self.compress = compress
+        self.loop = loop
+        self.length = None
+        if response_class is None:
+            real_response_class = ClientResponse
+        else:
+            real_response_class = response_class
+        self.response_class: Type[ClientResponse] = real_response_class
+        self._timer = timer if timer is not None else TimerNoop()
+        self._ssl = ssl if ssl is not None else True
+        self.server_hostname = server_hostname
+
+        if loop.get_debug():
+            self._source_traceback = traceback.extract_stack(sys._getframe(1))
+
+        self.update_version(version)
+        self.update_host(url)
+        self.update_headers(headers)
+        self.update_auto_headers(skip_auto_headers)
+        self.update_cookies(cookies)
+        self.update_content_encoding(data)
+        self.update_auth(auth, trust_env)
+        self.update_proxy(proxy, proxy_auth, proxy_headers)
+
+        self.update_body_from_data(data)
+        if data is not None or self.method not in self.GET_METHODS:
+            self.update_transfer_encoding()
+        self.update_expect_continue(expect100)
+        if traces is None:
+            traces = []
+        self._traces = traces
+
+    def __reset_writer(self, _: object = None) -> None:
+        self.__writer = None
+
+    @property
+    def _writer(self) -> Optional["asyncio.Task[None]"]:
+        return self.__writer
+
+    @_writer.setter
+    def _writer(self, writer: Optional["asyncio.Task[None]"]) -> None:
+        if self.__writer is not None:
+            self.__writer.remove_done_callback(self.__reset_writer)
+        self.__writer = writer
+        if writer is not None:
+            writer.add_done_callback(self.__reset_writer)
+
+    def is_ssl(self) -> bool:
+        return self.url.scheme in ("https", "wss")
+
+    @property
+    def ssl(self) -> Union["SSLContext", bool, Fingerprint]:
+        return self._ssl
+
+    @property
+    def connection_key(self) -> ConnectionKey:
+        proxy_headers = self.proxy_headers
+        if proxy_headers:
+            h: Optional[int] = hash(tuple((k, v) for k, v in proxy_headers.items()))
+        else:
+            h = None
+        return ConnectionKey(
+            self.host,
+            self.port,
+            self.is_ssl(),
+            self.ssl,
+            self.proxy,
+            self.proxy_auth,
+            h,
+        )
+
+    @property
+    def host(self) -> str:
+        ret = self.url.raw_host
+        assert ret is not None
+        return ret
+
+    @property
+    def port(self) -> Optional[int]:
+        return self.url.port
+
+    @property
+    def request_info(self) -> RequestInfo:
+        headers: CIMultiDictProxy[str] = CIMultiDictProxy(self.headers)
+        return RequestInfo(self.url, self.method, headers, self.original_url)
+
+    def update_host(self, url: URL) -> None:
+        """Update destination host, port and connection type (ssl)."""
+        # get host/port
+        if not url.raw_host:
+            raise InvalidURL(url)
+
+        # basic auth info
+        username, password = url.user, url.password
+        if username:
+            self.auth = helpers.BasicAuth(username, password or "")
+
+    def update_version(self, version: Union[http.HttpVersion, str]) -> None:
+        """Convert request version to two elements tuple.
+
+        parser HTTP version '1.1' => (1, 1)
+        """
+        if isinstance(version, str):
+            v = [part.strip() for part in version.split(".", 1)]
+            try:
+                version = http.HttpVersion(int(v[0]), int(v[1]))
+            except ValueError:
+                raise ValueError(
+                    f"Can not parse http version number: {version}"
+                ) from None
+        self.version = version
+
+    def update_headers(self, headers: Optional[LooseHeaders]) -> None:
+        """Update request headers."""
+        self.headers: CIMultiDict[str] = CIMultiDict()
+
+        # add host
+        netloc = cast(str, self.url.raw_host)
+        if helpers.is_ipv6_address(netloc):
+            netloc = f"[{netloc}]"
+        # See https://github.com/aio-libs/aiohttp/issues/3636.
+        netloc = netloc.rstrip(".")
+        if self.url.port is not None and not self.url.is_default_port():
+            netloc += ":" + str(self.url.port)
+        self.headers[hdrs.HOST] = netloc
+
+        if headers:
+            if isinstance(headers, (dict, MultiDictProxy, MultiDict)):
+                headers = headers.items()  # type: ignore[assignment]
+
+            for key, value in headers:  # type: ignore[misc]
+                # A special case for Host header
+                if key.lower() == "host":
+                    self.headers[key] = value
+                else:
+                    self.headers.add(key, value)
+
+    def update_auto_headers(self, skip_auto_headers: Iterable[str]) -> None:
+        self.skip_auto_headers = CIMultiDict(
+            (hdr, None) for hdr in sorted(skip_auto_headers)
+        )
+        used_headers = self.headers.copy()
+        used_headers.extend(self.skip_auto_headers)  # type: ignore[arg-type]
+
+        for hdr, val in self.DEFAULT_HEADERS.items():
+            if hdr not in used_headers:
+                self.headers.add(hdr, val)
+
+        if hdrs.USER_AGENT not in used_headers:
+            self.headers[hdrs.USER_AGENT] = SERVER_SOFTWARE
+
+    def update_cookies(self, cookies: Optional[LooseCookies]) -> None:
+        """Update request cookies header."""
+        if not cookies:
+            return
+
+        c = SimpleCookie()
+        if hdrs.COOKIE in self.headers:
+            c.load(self.headers.get(hdrs.COOKIE, ""))
+            del self.headers[hdrs.COOKIE]
+
+        if isinstance(cookies, Mapping):
+            iter_cookies = cookies.items()
+        else:
+            iter_cookies = cookies  # type: ignore[assignment]
+        for name, value in iter_cookies:
+            if isinstance(value, Morsel):
+                # Preserve coded_value
+                mrsl_val = value.get(value.key, Morsel())
+                mrsl_val.set(value.key, value.value, value.coded_value)
+                c[name] = mrsl_val
+            else:
+                c[name] = value  # type: ignore[assignment]
+
+        self.headers[hdrs.COOKIE] = c.output(header="", sep=";").strip()
+
+    def update_content_encoding(self, data: Any) -> None:
+        """Set request content encoding."""
+        if data is None:
+            return
+
+        enc = self.headers.get(hdrs.CONTENT_ENCODING, "").lower()
+        if enc:
+            if self.compress:
+                raise ValueError(
+                    "compress can not be set " "if Content-Encoding header is set"
+                )
+        elif self.compress:
+            if not isinstance(self.compress, str):
+                self.compress = "deflate"
+            self.headers[hdrs.CONTENT_ENCODING] = self.compress
+            self.chunked = True  # enable chunked, no need to deal with length
+
+    def update_transfer_encoding(self) -> None:
+        """Analyze transfer-encoding header."""
+        te = self.headers.get(hdrs.TRANSFER_ENCODING, "").lower()
+
+        if "chunked" in te:
+            if self.chunked:
+                raise ValueError(
+                    "chunked can not be set "
+                    'if "Transfer-Encoding: chunked" header is set'
+                )
+
+        elif self.chunked:
+            if hdrs.CONTENT_LENGTH in self.headers:
+                raise ValueError(
+                    "chunked can not be set " "if Content-Length header is set"
+                )
+
+            self.headers[hdrs.TRANSFER_ENCODING] = "chunked"
+        else:
+            if hdrs.CONTENT_LENGTH not in self.headers:
+                self.headers[hdrs.CONTENT_LENGTH] = str(len(self.body))
+
+    def update_auth(self, auth: Optional[BasicAuth], trust_env: bool = False) -> None:
+        """Set basic auth."""
+        if auth is None:
+            auth = self.auth
+        if auth is None and trust_env and self.url.host is not None:
+            netrc_obj = netrc_from_env()
+            with contextlib.suppress(LookupError):
+                auth = basicauth_from_netrc(netrc_obj, self.url.host)
+        if auth is None:
+            return
+
+        if not isinstance(auth, helpers.BasicAuth):
+            raise TypeError("BasicAuth() tuple is required instead")
+
+        self.headers[hdrs.AUTHORIZATION] = auth.encode()
+
+    def update_body_from_data(self, body: Any) -> None:
+        if body is None:
+            return
+
+        # FormData
+        if isinstance(body, FormData):
+            body = body()
+
+        try:
+            body = payload.PAYLOAD_REGISTRY.get(body, disposition=None)
+        except payload.LookupError:
+            body = FormData(body)()
+
+        self.body = body
+
+        # enable chunked encoding if needed
+        if not self.chunked:
+            if hdrs.CONTENT_LENGTH not in self.headers:
+                size = body.size
+                if size is None:
+                    self.chunked = True
+                else:
+                    if hdrs.CONTENT_LENGTH not in self.headers:
+                        self.headers[hdrs.CONTENT_LENGTH] = str(size)
+
+        # copy payload headers
+        assert body.headers
+        for (key, value) in body.headers.items():
+            if key in self.headers:
+                continue
+            if key in self.skip_auto_headers:
+                continue
+            self.headers[key] = value
+
+    def update_expect_continue(self, expect: bool = False) -> None:
+        if expect:
+            self.headers[hdrs.EXPECT] = "100-continue"
+        elif self.headers.get(hdrs.EXPECT, "").lower() == "100-continue":
+            expect = True
+
+        if expect:
+            self._continue = self.loop.create_future()
+
+    def update_proxy(
+        self,
+        proxy: Optional[URL],
+        proxy_auth: Optional[BasicAuth],
+        proxy_headers: Optional[LooseHeaders],
+    ) -> None:
+        if proxy_auth and not isinstance(proxy_auth, helpers.BasicAuth):
+            raise ValueError("proxy_auth must be None or BasicAuth() tuple")
+        self.proxy = proxy
+        self.proxy_auth = proxy_auth
+        self.proxy_headers = proxy_headers
+
+    def keep_alive(self) -> bool:
+        if self.version < HttpVersion10:
+            # keep alive not supported at all
+            return False
+        if self.version == HttpVersion10:
+            if self.headers.get(hdrs.CONNECTION) == "keep-alive":
+                return True
+            else:  # no headers means we close for Http 1.0
+                return False
+        elif self.headers.get(hdrs.CONNECTION) == "close":
+            return False
+
+        return True
+
+    async def write_bytes(
+        self, writer: AbstractStreamWriter, conn: "Connection"
+    ) -> None:
+        """Support coroutines that yields bytes objects."""
+        # 100 response
+        if self._continue is not None:
+            try:
+                await writer.drain()
+                await self._continue
+            except asyncio.CancelledError:
+                return
+
+        protocol = conn.protocol
+        assert protocol is not None
+        try:
+            if isinstance(self.body, payload.Payload):
+                await self.body.write(writer)
+            else:
+                if isinstance(self.body, (bytes, bytearray)):
+                    self.body = (self.body,)  # type: ignore[assignment]
+
+                for chunk in self.body:
+                    await writer.write(chunk)  # type: ignore[arg-type]
+        except OSError as underlying_exc:
+            reraised_exc = underlying_exc
+
+            exc_is_not_timeout = underlying_exc.errno is not None or not isinstance(
+                underlying_exc, asyncio.TimeoutError
+            )
+            if exc_is_not_timeout:
+                reraised_exc = ClientOSError(
+                    underlying_exc.errno,
+                    f"Can not write request body for {self.url !s}",
+                )
+
+            set_exception(protocol, reraised_exc, underlying_exc)
+        except asyncio.CancelledError:
+            await writer.write_eof()
+        except Exception as underlying_exc:
+            set_exception(
+                protocol,
+                ClientConnectionError(
+                    f"Failed to send bytes into the underlying connection {conn !s}",
+                ),
+                underlying_exc,
+            )
+        else:
+            await writer.write_eof()
+            protocol.start_timeout()
+
+    async def send(self, conn: "Connection") -> "ClientResponse":
+        # Specify request target:
+        # - CONNECT request must send authority form URI
+        # - not CONNECT proxy must send absolute form URI
+        # - most common is origin form URI
+        if self.method == hdrs.METH_CONNECT:
+            connect_host = self.url.raw_host
+            assert connect_host is not None
+            if helpers.is_ipv6_address(connect_host):
+                connect_host = f"[{connect_host}]"
+            path = f"{connect_host}:{self.url.port}"
+        elif self.proxy and not self.is_ssl():
+            path = str(self.url)
+        else:
+            path = self.url.raw_path
+            if self.url.raw_query_string:
+                path += "?" + self.url.raw_query_string
+
+        protocol = conn.protocol
+        assert protocol is not None
+        writer = StreamWriter(
+            protocol,
+            self.loop,
+            on_chunk_sent=functools.partial(
+                self._on_chunk_request_sent, self.method, self.url
+            ),
+            on_headers_sent=functools.partial(
+                self._on_headers_request_sent, self.method, self.url
+            ),
+        )
+
+        if self.compress:
+            writer.enable_compression(self.compress)
+
+        if self.chunked is not None:
+            writer.enable_chunking()
+
+        # set default content-type
+        if (
+            self.method in self.POST_METHODS
+            and hdrs.CONTENT_TYPE not in self.skip_auto_headers
+            and hdrs.CONTENT_TYPE not in self.headers
+        ):
+            self.headers[hdrs.CONTENT_TYPE] = "application/octet-stream"
+
+        # set the connection header
+        connection = self.headers.get(hdrs.CONNECTION)
+        if not connection:
+            if self.keep_alive():
+                if self.version == HttpVersion10:
+                    connection = "keep-alive"
+            else:
+                if self.version == HttpVersion11:
+                    connection = "close"
+
+        if connection is not None:
+            self.headers[hdrs.CONNECTION] = connection
+
+        # status + headers
+        status_line = "{0} {1} HTTP/{v.major}.{v.minor}".format(
+            self.method, path, v=self.version
+        )
+        await writer.write_headers(status_line, self.headers)
+
+        self._writer = self.loop.create_task(self.write_bytes(writer, conn))
+
+        response_class = self.response_class
+        assert response_class is not None
+        self.response = response_class(
+            self.method,
+            self.original_url,
+            writer=self._writer,
+            continue100=self._continue,
+            timer=self._timer,
+            request_info=self.request_info,
+            traces=self._traces,
+            loop=self.loop,
+            session=self._session,
+        )
+        return self.response
+
+    async def close(self) -> None:
+        if self._writer is not None:
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._writer
+
+    def terminate(self) -> None:
+        if self._writer is not None:
+            if not self.loop.is_closed():
+                self._writer.cancel()
+            self._writer.remove_done_callback(self.__reset_writer)
+            self._writer = None
+
+    async def _on_chunk_request_sent(self, method: str, url: URL, chunk: bytes) -> None:
+        for trace in self._traces:
+            await trace.send_request_chunk_sent(method, url, chunk)
+
+    async def _on_headers_request_sent(
+        self, method: str, url: URL, headers: "CIMultiDict[str]"
+    ) -> None:
+        for trace in self._traces:
+            await trace.send_request_headers(method, url, headers)
+
+
+class ClientResponse(HeadersMixin):
+
+    # Some of these attributes are None when created,
+    # but will be set by the start() method.
+    # As the end user will likely never see the None values, we cheat the types below.
+    # from the Status-Line of the response
+    version: Optional[HttpVersion] = None  # HTTP-Version
+    status: int = None  # type: ignore[assignment] # Status-Code
+    reason: Optional[str] = None  # Reason-Phrase
+
+    content: StreamReader = None  # type: ignore[assignment]  # Payload stream
+    _headers: CIMultiDictProxy[str] = None  # type: ignore[assignment]
+    _raw_headers: RawHeaders = None  # type: ignore[assignment]
+
+    _connection = None  # current connection
+    _source_traceback: Optional[traceback.StackSummary] = None
+    # set up by ClientRequest after ClientResponse object creation
+    # post-init stage allows to not change ctor signature
+    _closed = True  # to allow __del__ for non-initialized properly response
+    _released = False
+    __writer = None
+
+    def __init__(
+        self,
+        method: str,
+        url: URL,
+        *,
+        writer: "asyncio.Task[None]",
+        continue100: Optional["asyncio.Future[bool]"],
+        timer: BaseTimerContext,
+        request_info: RequestInfo,
+        traces: List["Trace"],
+        loop: asyncio.AbstractEventLoop,
+        session: "ClientSession",
+    ) -> None:
+        assert isinstance(url, URL)
+
+        self.method = method
+        self.cookies = SimpleCookie()
+
+        self._real_url = url
+        self._url = url.with_fragment(None)
+        self._body: Any = None
+        self._writer: Optional[asyncio.Task[None]] = writer
+        self._continue = continue100  # None by default
+        self._closed = True
+        self._history: Tuple[ClientResponse, ...] = ()
+        self._request_info = request_info
+        self._timer = timer if timer is not None else TimerNoop()
+        self._cache: Dict[str, Any] = {}
+        self._traces = traces
+        self._loop = loop
+        # store a reference to session #1985
+        self._session: Optional[ClientSession] = session
+        # Save reference to _resolve_charset, so that get_encoding() will still
+        # work after the response has finished reading the body.
+        if session is None:
+            # TODO: Fix session=None in tests (see ClientRequest.__init__).
+            self._resolve_charset: Callable[
+                ["ClientResponse", bytes], str
+            ] = lambda *_: "utf-8"
+        else:
+            self._resolve_charset = session._resolve_charset
+        if loop.get_debug():
+            self._source_traceback = traceback.extract_stack(sys._getframe(1))
+
+    def __reset_writer(self, _: object = None) -> None:
+        self.__writer = None
+
+    @property
+    def _writer(self) -> Optional["asyncio.Task[None]"]:
+        return self.__writer
+
+    @_writer.setter
+    def _writer(self, writer: Optional["asyncio.Task[None]"]) -> None:
+        if self.__writer is not None:
+            self.__writer.remove_done_callback(self.__reset_writer)
+        self.__writer = writer
+        if writer is not None:
+            writer.add_done_callback(self.__reset_writer)
+
+    @reify
+    def url(self) -> URL:
+        return self._url
+
+    @reify
+    def url_obj(self) -> URL:
+        warnings.warn("Deprecated, use .url #1654", DeprecationWarning, stacklevel=2)
+        return self._url
+
+    @reify
+    def real_url(self) -> URL:
+        return self._real_url
+
+    @reify
+    def host(self) -> str:
+        assert self._url.host is not None
+        return self._url.host
+
+    @reify
+    def headers(self) -> "CIMultiDictProxy[str]":
+        return self._headers
+
+    @reify
+    def raw_headers(self) -> RawHeaders:
+        return self._raw_headers
+
+    @reify
+    def request_info(self) -> RequestInfo:
+        return self._request_info
+
+    @reify
+    def content_disposition(self) -> Optional[ContentDisposition]:
+        raw = self._headers.get(hdrs.CONTENT_DISPOSITION)
+        if raw is None:
+            return None
+        disposition_type, params_dct = multipart.parse_content_disposition(raw)
+        params = MappingProxyType(params_dct)
+        filename = multipart.content_disposition_filename(params)
+        return ContentDisposition(disposition_type, params, filename)
+
+    def __del__(self, _warnings: Any = warnings) -> None:
+        if self._closed:
+            return
+
+        if self._connection is not None:
+            self._connection.release()
+            self._cleanup_writer()
+
+            if self._loop.get_debug():
+                kwargs = {"source": self}
+                _warnings.warn(f"Unclosed response {self!r}", ResourceWarning, **kwargs)
+                context = {"client_response": self, "message": "Unclosed response"}
+                if self._source_traceback:
+                    context["source_traceback"] = self._source_traceback
+                self._loop.call_exception_handler(context)
+
+    def __repr__(self) -> str:
+        out = io.StringIO()
+        ascii_encodable_url = str(self.url)
+        if self.reason:
+            ascii_encodable_reason = self.reason.encode(
+                "ascii", "backslashreplace"
+            ).decode("ascii")
+        else:
+            ascii_encodable_reason = "None"
+        print(
+            "<ClientResponse({}) [{} {}]>".format(
+                ascii_encodable_url, self.status, ascii_encodable_reason
+            ),
+            file=out,
+        )
+        print(self.headers, file=out)
+        return out.getvalue()
+
+    @property
+    def connection(self) -> Optional["Connection"]:
+        return self._connection
+
+    @reify
+    def history(self) -> Tuple["ClientResponse", ...]:
+        """A sequence of of responses, if redirects occurred."""
+        return self._history
+
+    @reify
+    def links(self) -> "MultiDictProxy[MultiDictProxy[Union[str, URL]]]":
+        links_str = ", ".join(self.headers.getall("link", []))
+
+        if not links_str:
+            return MultiDictProxy(MultiDict())
+
+        links: MultiDict[MultiDictProxy[Union[str, URL]]] = MultiDict()
+
+        for val in re.split(r",(?=\s*<)", links_str):
+            match = re.match(r"\s*<(.*)>(.*)", val)
+            if match is None:  # pragma: no cover
+                # the check exists to suppress mypy error
+                continue
+            url, params_str = match.groups()
+            params = params_str.split(";")[1:]
+
+            link: MultiDict[Union[str, URL]] = MultiDict()
+
+            for param in params:
+                match = re.match(r"^\s*(\S*)\s*=\s*(['\"]?)(.*?)(\2)\s*$", param, re.M)
+                if match is None:  # pragma: no cover
+                    # the check exists to suppress mypy error
+                    continue
+                key, _, value, _ = match.groups()
+
+                link.add(key, value)
+
+            key = link.get("rel", url)
+
+            link.add("url", self.url.join(URL(url)))
+
+            links.add(str(key), MultiDictProxy(link))
+
+        return MultiDictProxy(links)
+
+    async def start(self, connection: "Connection") -> "ClientResponse":
+        """Start response processing."""
+        self._closed = False
+        self._protocol = connection.protocol
+        self._connection = connection
+
+        with self._timer:
+            while True:
+                # read response
+                try:
+                    protocol = self._protocol
+                    message, payload = await protocol.read()  # type: ignore[union-attr]
+                except http.HttpProcessingError as exc:
+                    raise ClientResponseError(
+                        self.request_info,
+                        self.history,
+                        status=exc.code,
+                        message=exc.message,
+                        headers=exc.headers,
+                    ) from exc
+
+                if message.code < 100 or message.code > 199 or message.code == 101:
+                    break
+
+                if self._continue is not None:
+                    set_result(self._continue, True)
+                    self._continue = None
+
+        # payload eof handler
+        payload.on_eof(self._response_eof)
+
+        # response status
+        self.version = message.version
+        self.status = message.code
+        self.reason = message.reason
+
+        # headers
+        self._headers = message.headers  # type is CIMultiDictProxy
+        self._raw_headers = message.raw_headers  # type is Tuple[bytes, bytes]
+
+        # payload
+        self.content = payload
+
+        # cookies
+        for hdr in self.headers.getall(hdrs.SET_COOKIE, ()):
+            try:
+                self.cookies.load(hdr)
+            except CookieError as exc:
+                client_logger.warning("Can not load response cookies: %s", exc)
+        return self
+
+    def _response_eof(self) -> None:
+        if self._closed:
+            return
+
+        # protocol could be None because connection could be detached
+        protocol = self._connection and self._connection.protocol
+        if protocol is not None and protocol.upgraded:
+            return
+
+        self._closed = True
+        self._cleanup_writer()
+        self._release_connection()
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def close(self) -> None:
+        if not self._released:
+            self._notify_content()
+
+        self._closed = True
+        if self._loop is None or self._loop.is_closed():
+            return
+
+        self._cleanup_writer()
+        if self._connection is not None:
+            self._connection.close()
+            self._connection = None
+
+    def release(self) -> Any:
+        if not self._released:
+            self._notify_content()
+
+        self._closed = True
+
+        self._cleanup_writer()
+        self._release_connection()
+        return noop()
+
+    @property
+    def ok(self) -> bool:
+        """Returns ``True`` if ``status`` is less than ``400``, ``False`` if not.
+
+        This is **not** a check for ``200 OK`` but a check that the response
+        status is under 400.
+        """
+        return 400 > self.status
+
+    def raise_for_status(self) -> None:
+        if not self.ok:
+            # reason should always be not None for a started response
+            assert self.reason is not None
+            self.release()
+            raise ClientResponseError(
+                self.request_info,
+                self.history,
+                status=self.status,
+                message=self.reason,
+                headers=self.headers,
+            )
+
+    def _release_connection(self) -> None:
+        if self._connection is not None:
+            if self._writer is None:
+                self._connection.release()
+                self._connection = None
+            else:
+                self._writer.add_done_callback(lambda f: self._release_connection())
+
+    async def _wait_released(self) -> None:
+        if self._writer is not None:
+            await self._writer
+        self._release_connection()
+
+    def _cleanup_writer(self) -> None:
+        if self._writer is not None:
+            self._writer.cancel()
+        self._session = None
+
+    def _notify_content(self) -> None:
+        content = self.content
+        if content and content.exception() is None:
+            set_exception(content, ClientConnectionError("Connection closed"))
+        self._released = True
+
+    async def wait_for_close(self) -> None:
+        if self._writer is not None:
+            await self._writer
+        self.release()
+
+    async def read(self) -> bytes:
+        """Read response payload."""
+        if self._body is None:
+            try:
+                self._body = await self.content.read()
+                for trace in self._traces:
+                    await trace.send_response_chunk_received(
+                        self.method, self.url, self._body
+                    )
+            except BaseException:
+                self.close()
+                raise
+        elif self._released:  # Response explicitly released
+            raise ClientConnectionError("Connection closed")
+
+        protocol = self._connection and self._connection.protocol
+        if protocol is None or not protocol.upgraded:
+            await self._wait_released()  # Underlying connection released
+        return self._body  # type: ignore[no-any-return]
+
+    def get_encoding(self) -> str:
+        ctype = self.headers.get(hdrs.CONTENT_TYPE, "").lower()
+        mimetype = helpers.parse_mimetype(ctype)
+
+        encoding = mimetype.parameters.get("charset")
+        if encoding:
+            with contextlib.suppress(LookupError):
+                return codecs.lookup(encoding).name
+
+        if mimetype.type == "application" and (
+            mimetype.subtype == "json" or mimetype.subtype == "rdap"
+        ):
+            # RFC 7159 states that the default encoding is UTF-8.
+            # RFC 7483 defines application/rdap+json
+            return "utf-8"
+
+        if self._body is None:
+            raise RuntimeError(
+                "Cannot compute fallback encoding of a not yet read body"
+            )
+
+        return self._resolve_charset(self, self._body)
+
+    async def text(self, encoding: Optional[str] = None, errors: str = "strict") -> str:
+        """Read response payload and decode."""
+        if self._body is None:
+            await self.read()
+
+        if encoding is None:
+            encoding = self.get_encoding()
+
+        return self._body.decode(  # type: ignore[no-any-return,union-attr]
+            encoding, errors=errors
+        )
+
+    async def json(
+        self,
+        *,
+        encoding: Optional[str] = None,
+        loads: JSONDecoder = DEFAULT_JSON_DECODER,
+        content_type: Optional[str] = "application/json",
+    ) -> Any:
+        """Read and decodes JSON response."""
+        if self._body is None:
+            await self.read()
+
+        if content_type:
+            ctype = self.headers.get(hdrs.CONTENT_TYPE, "").lower()
+            if not _is_expected_content_type(ctype, content_type):
+                raise ContentTypeError(
+                    self.request_info,
+                    self.history,
+                    message=(
+                        "Attempt to decode JSON with " "unexpected mimetype: %s" % ctype
+                    ),
+                    headers=self.headers,
+                )
+
+        stripped = self._body.strip()  # type: ignore[union-attr]
+        if not stripped:
+            return None
+
+        if encoding is None:
+            encoding = self.get_encoding()
+
+        return loads(stripped.decode(encoding))
+
+    async def __aenter__(self) -> "ClientResponse":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        # similar to _RequestContextManager, we do not need to check
+        # for exceptions, response object can close connection
+        # if state is broken
+        self.release()
+        await self.wait_for_close()

env-llmeval/lib/python3.10/site-packages/aiohttp/client_ws.py

@@ -0,0 +1,315 @@
+"""WebSocket client for asyncio."""
+
+import asyncio
+import sys
+from typing import Any, Optional, cast
+
+from .client_exceptions import ClientError
+from .client_reqrep import ClientResponse
+from .helpers import call_later, set_result
+from .http import (
+    WS_CLOSED_MESSAGE,
+    WS_CLOSING_MESSAGE,
+    WebSocketError,
+    WSCloseCode,
+    WSMessage,
+    WSMsgType,
+)
+from .http_websocket import WebSocketWriter  # WSMessage
+from .streams import EofStream, FlowControlDataQueue
+from .typedefs import (
+    DEFAULT_JSON_DECODER,
+    DEFAULT_JSON_ENCODER,
+    JSONDecoder,
+    JSONEncoder,
+)
+
+if sys.version_info >= (3, 11):
+    import asyncio as async_timeout
+else:
+    import async_timeout
+
+
+class ClientWebSocketResponse:
+    def __init__(
+        self,
+        reader: "FlowControlDataQueue[WSMessage]",
+        writer: WebSocketWriter,
+        protocol: Optional[str],
+        response: ClientResponse,
+        timeout: float,
+        autoclose: bool,
+        autoping: bool,
+        loop: asyncio.AbstractEventLoop,
+        *,
+        receive_timeout: Optional[float] = None,
+        heartbeat: Optional[float] = None,
+        compress: int = 0,
+        client_notakeover: bool = False,
+    ) -> None:
+        self._response = response
+        self._conn = response.connection
+
+        self._writer = writer
+        self._reader = reader
+        self._protocol = protocol
+        self._closed = False
+        self._closing = False
+        self._close_code: Optional[int] = None
+        self._timeout = timeout
+        self._receive_timeout = receive_timeout
+        self._autoclose = autoclose
+        self._autoping = autoping
+        self._heartbeat = heartbeat
+        self._heartbeat_cb: Optional[asyncio.TimerHandle] = None
+        if heartbeat is not None:
+            self._pong_heartbeat = heartbeat / 2.0
+        self._pong_response_cb: Optional[asyncio.TimerHandle] = None
+        self._loop = loop
+        self._waiting: Optional[asyncio.Future[bool]] = None
+        self._exception: Optional[BaseException] = None
+        self._compress = compress
+        self._client_notakeover = client_notakeover
+
+        self._reset_heartbeat()
+
+    def _cancel_heartbeat(self) -> None:
+        if self._pong_response_cb is not None:
+            self._pong_response_cb.cancel()
+            self._pong_response_cb = None
+
+        if self._heartbeat_cb is not None:
+            self._heartbeat_cb.cancel()
+            self._heartbeat_cb = None
+
+    def _reset_heartbeat(self) -> None:
+        self._cancel_heartbeat()
+
+        if self._heartbeat is not None:
+            self._heartbeat_cb = call_later(
+                self._send_heartbeat,
+                self._heartbeat,
+                self._loop,
+                timeout_ceil_threshold=self._conn._connector._timeout_ceil_threshold
+                if self._conn is not None
+                else 5,
+            )
+
+    def _send_heartbeat(self) -> None:
+        if self._heartbeat is not None and not self._closed:
+            # fire-and-forget a task is not perfect but maybe ok for
+            # sending ping. Otherwise we need a long-living heartbeat
+            # task in the class.
+            self._loop.create_task(self._writer.ping())
+
+            if self._pong_response_cb is not None:
+                self._pong_response_cb.cancel()
+            self._pong_response_cb = call_later(
+                self._pong_not_received,
+                self._pong_heartbeat,
+                self._loop,
+                timeout_ceil_threshold=self._conn._connector._timeout_ceil_threshold
+                if self._conn is not None
+                else 5,
+            )
+
+    def _pong_not_received(self) -> None:
+        if not self._closed:
+            self._closed = True
+            self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+            self._exception = asyncio.TimeoutError()
+            self._response.close()
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    @property
+    def close_code(self) -> Optional[int]:
+        return self._close_code
+
+    @property
+    def protocol(self) -> Optional[str]:
+        return self._protocol
+
+    @property
+    def compress(self) -> int:
+        return self._compress
+
+    @property
+    def client_notakeover(self) -> bool:
+        return self._client_notakeover
+
+    def get_extra_info(self, name: str, default: Any = None) -> Any:
+        """extra info from connection transport"""
+        conn = self._response.connection
+        if conn is None:
+            return default
+        transport = conn.transport
+        if transport is None:
+            return default
+        return transport.get_extra_info(name, default)
+
+    def exception(self) -> Optional[BaseException]:
+        return self._exception
+
+    async def ping(self, message: bytes = b"") -> None:
+        await self._writer.ping(message)
+
+    async def pong(self, message: bytes = b"") -> None:
+        await self._writer.pong(message)
+
+    async def send_str(self, data: str, compress: Optional[int] = None) -> None:
+        if not isinstance(data, str):
+            raise TypeError("data argument must be str (%r)" % type(data))
+        await self._writer.send(data, binary=False, compress=compress)
+
+    async def send_bytes(self, data: bytes, compress: Optional[int] = None) -> None:
+        if not isinstance(data, (bytes, bytearray, memoryview)):
+            raise TypeError("data argument must be byte-ish (%r)" % type(data))
+        await self._writer.send(data, binary=True, compress=compress)
+
+    async def send_json(
+        self,
+        data: Any,
+        compress: Optional[int] = None,
+        *,
+        dumps: JSONEncoder = DEFAULT_JSON_ENCODER,
+    ) -> None:
+        await self.send_str(dumps(data), compress=compress)
+
+    async def close(self, *, code: int = WSCloseCode.OK, message: bytes = b"") -> bool:
+        # we need to break `receive()` cycle first,
+        # `close()` may be called from different task
+        if self._waiting is not None and not self._closing:
+            self._closing = True
+            self._reader.feed_data(WS_CLOSING_MESSAGE, 0)
+            await self._waiting
+
+        if not self._closed:
+            self._cancel_heartbeat()
+            self._closed = True
+            try:
+                await self._writer.close(code, message)
+            except asyncio.CancelledError:
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                self._response.close()
+                raise
+            except Exception as exc:
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                self._exception = exc
+                self._response.close()
+                return True
+
+            if self._close_code:
+                self._response.close()
+                return True
+
+            while True:
+                try:
+                    async with async_timeout.timeout(self._timeout):
+                        msg = await self._reader.read()
+                except asyncio.CancelledError:
+                    self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                    self._response.close()
+                    raise
+                except Exception as exc:
+                    self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                    self._exception = exc
+                    self._response.close()
+                    return True
+
+                if msg.type == WSMsgType.CLOSE:
+                    self._close_code = msg.data
+                    self._response.close()
+                    return True
+        else:
+            return False
+
+    async def receive(self, timeout: Optional[float] = None) -> WSMessage:
+        while True:
+            if self._waiting is not None:
+                raise RuntimeError("Concurrent call to receive() is not allowed")
+
+            if self._closed:
+                return WS_CLOSED_MESSAGE
+            elif self._closing:
+                await self.close()
+                return WS_CLOSED_MESSAGE
+
+            try:
+                self._waiting = self._loop.create_future()
+                try:
+                    async with async_timeout.timeout(timeout or self._receive_timeout):
+                        msg = await self._reader.read()
+                    self._reset_heartbeat()
+                finally:
+                    waiter = self._waiting
+                    self._waiting = None
+                    set_result(waiter, True)
+            except (asyncio.CancelledError, asyncio.TimeoutError):
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                raise
+            except EofStream:
+                self._close_code = WSCloseCode.OK
+                await self.close()
+                return WSMessage(WSMsgType.CLOSED, None, None)
+            except ClientError:
+                self._closed = True
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                return WS_CLOSED_MESSAGE
+            except WebSocketError as exc:
+                self._close_code = exc.code
+                await self.close(code=exc.code)
+                return WSMessage(WSMsgType.ERROR, exc, None)
+            except Exception as exc:
+                self._exception = exc
+                self._closing = True
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                await self.close()
+                return WSMessage(WSMsgType.ERROR, exc, None)
+
+            if msg.type == WSMsgType.CLOSE:
+                self._closing = True
+                self._close_code = msg.data
+                if not self._closed and self._autoclose:
+                    await self.close()
+            elif msg.type == WSMsgType.CLOSING:
+                self._closing = True
+            elif msg.type == WSMsgType.PING and self._autoping:
+                await self.pong(msg.data)
+                continue
+            elif msg.type == WSMsgType.PONG and self._autoping:
+                continue
+
+            return msg
+
+    async def receive_str(self, *, timeout: Optional[float] = None) -> str:
+        msg = await self.receive(timeout)
+        if msg.type != WSMsgType.TEXT:
+            raise TypeError(f"Received message {msg.type}:{msg.data!r} is not str")
+        return cast(str, msg.data)
+
+    async def receive_bytes(self, *, timeout: Optional[float] = None) -> bytes:
+        msg = await self.receive(timeout)
+        if msg.type != WSMsgType.BINARY:
+            raise TypeError(f"Received message {msg.type}:{msg.data!r} is not bytes")
+        return cast(bytes, msg.data)
+
+    async def receive_json(
+        self,
+        *,
+        loads: JSONDecoder = DEFAULT_JSON_DECODER,
+        timeout: Optional[float] = None,
+    ) -> Any:
+        data = await self.receive_str(timeout=timeout)
+        return loads(data)
+
+    def __aiter__(self) -> "ClientWebSocketResponse":
+        return self
+
+    async def __anext__(self) -> WSMessage:
+        msg = await self.receive()
+        if msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.CLOSED):
+            raise StopAsyncIteration
+        return msg

env-llmeval/lib/python3.10/site-packages/aiohttp/compression_utils.py

@@ -0,0 +1,157 @@
+import asyncio
+import zlib
+from concurrent.futures import Executor
+from typing import Optional, cast
+
+try:
+    try:
+        import brotlicffi as brotli
+    except ImportError:
+        import brotli
+
+    HAS_BROTLI = True
+except ImportError:  # pragma: no cover
+    HAS_BROTLI = False
+
+MAX_SYNC_CHUNK_SIZE = 1024
+
+
+def encoding_to_mode(
+    encoding: Optional[str] = None,
+    suppress_deflate_header: bool = False,
+) -> int:
+    if encoding == "gzip":
+        return 16 + zlib.MAX_WBITS
+
+    return -zlib.MAX_WBITS if suppress_deflate_header else zlib.MAX_WBITS
+
+
+class ZlibBaseHandler:
+    def __init__(
+        self,
+        mode: int,
+        executor: Optional[Executor] = None,
+        max_sync_chunk_size: Optional[int] = MAX_SYNC_CHUNK_SIZE,
+    ):
+        self._mode = mode
+        self._executor = executor
+        self._max_sync_chunk_size = max_sync_chunk_size
+
+
+class ZLibCompressor(ZlibBaseHandler):
+    def __init__(
+        self,
+        encoding: Optional[str] = None,
+        suppress_deflate_header: bool = False,
+        level: Optional[int] = None,
+        wbits: Optional[int] = None,
+        strategy: int = zlib.Z_DEFAULT_STRATEGY,
+        executor: Optional[Executor] = None,
+        max_sync_chunk_size: Optional[int] = MAX_SYNC_CHUNK_SIZE,
+    ):
+        super().__init__(
+            mode=encoding_to_mode(encoding, suppress_deflate_header)
+            if wbits is None
+            else wbits,
+            executor=executor,
+            max_sync_chunk_size=max_sync_chunk_size,
+        )
+        if level is None:
+            self._compressor = zlib.compressobj(wbits=self._mode, strategy=strategy)
+        else:
+            self._compressor = zlib.compressobj(
+                wbits=self._mode, strategy=strategy, level=level
+            )
+        self._compress_lock = asyncio.Lock()
+
+    def compress_sync(self, data: bytes) -> bytes:
+        return self._compressor.compress(data)
+
+    async def compress(self, data: bytes) -> bytes:
+        async with self._compress_lock:
+            # To ensure the stream is consistent in the event
+            # there are multiple writers, we need to lock
+            # the compressor so that only one writer can
+            # compress at a time.
+            if (
+                self._max_sync_chunk_size is not None
+                and len(data) > self._max_sync_chunk_size
+            ):
+                return await asyncio.get_event_loop().run_in_executor(
+                    self._executor, self.compress_sync, data
+                )
+            return self.compress_sync(data)
+
+    def flush(self, mode: int = zlib.Z_FINISH) -> bytes:
+        return self._compressor.flush(mode)
+
+
+class ZLibDecompressor(ZlibBaseHandler):
+    def __init__(
+        self,
+        encoding: Optional[str] = None,
+        suppress_deflate_header: bool = False,
+        executor: Optional[Executor] = None,
+        max_sync_chunk_size: Optional[int] = MAX_SYNC_CHUNK_SIZE,
+    ):
+        super().__init__(
+            mode=encoding_to_mode(encoding, suppress_deflate_header),
+            executor=executor,
+            max_sync_chunk_size=max_sync_chunk_size,
+        )
+        self._decompressor = zlib.decompressobj(wbits=self._mode)
+
+    def decompress_sync(self, data: bytes, max_length: int = 0) -> bytes:
+        return self._decompressor.decompress(data, max_length)
+
+    async def decompress(self, data: bytes, max_length: int = 0) -> bytes:
+        if (
+            self._max_sync_chunk_size is not None
+            and len(data) > self._max_sync_chunk_size
+        ):
+            return await asyncio.get_event_loop().run_in_executor(
+                self._executor, self.decompress_sync, data, max_length
+            )
+        return self.decompress_sync(data, max_length)
+
+    def flush(self, length: int = 0) -> bytes:
+        return (
+            self._decompressor.flush(length)
+            if length > 0
+            else self._decompressor.flush()
+        )
+
+    @property
+    def eof(self) -> bool:
+        return self._decompressor.eof
+
+    @property
+    def unconsumed_tail(self) -> bytes:
+        return self._decompressor.unconsumed_tail
+
+    @property
+    def unused_data(self) -> bytes:
+        return self._decompressor.unused_data
+
+
+class BrotliDecompressor:
+    # Supports both 'brotlipy' and 'Brotli' packages
+    # since they share an import name. The top branches
+    # are for 'brotlipy' and bottom branches for 'Brotli'
+    def __init__(self) -> None:
+        if not HAS_BROTLI:
+            raise RuntimeError(
+                "The brotli decompression is not available. "
+                "Please install `Brotli` module"
+            )
+        self._obj = brotli.Decompressor()
+
+    def decompress_sync(self, data: bytes) -> bytes:
+        if hasattr(self._obj, "decompress"):
+            return cast(bytes, self._obj.decompress(data))
+        return cast(bytes, self._obj.process(data))
+
+    def flush(self) -> bytes:
+        if hasattr(self._obj, "flush"):
+            return cast(bytes, self._obj.flush())
+        return b""

env-llmeval/lib/python3.10/site-packages/aiohttp/connector.py

@@ -0,0 +1,1511 @@
+import asyncio
+import functools
+import random
+import sys
+import traceback
+import warnings
+from collections import defaultdict, deque
+from contextlib import suppress
+from http import HTTPStatus
+from http.cookies import SimpleCookie
+from itertools import cycle, islice
+from time import monotonic
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    DefaultDict,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+import attr
+
+from . import hdrs, helpers
+from .abc import AbstractResolver
+from .client_exceptions import (
+    ClientConnectionError,
+    ClientConnectorCertificateError,
+    ClientConnectorError,
+    ClientConnectorSSLError,
+    ClientHttpProxyError,
+    ClientProxyConnectionError,
+    ServerFingerprintMismatch,
+    UnixClientConnectorError,
+    cert_errors,
+    ssl_errors,
+)
+from .client_proto import ResponseHandler
+from .client_reqrep import ClientRequest, Fingerprint, _merge_ssl_params
+from .helpers import ceil_timeout, get_running_loop, is_ip_address, noop, sentinel
+from .locks import EventResultOrError
+from .resolver import DefaultResolver
+
+try:
+    import ssl
+
+    SSLContext = ssl.SSLContext
+except ImportError:  # pragma: no cover
+    ssl = None  # type: ignore[assignment]
+    SSLContext = object  # type: ignore[misc,assignment]
+
+
+__all__ = ("BaseConnector", "TCPConnector", "UnixConnector", "NamedPipeConnector")
+
+
+if TYPE_CHECKING:
+    from .client import ClientTimeout
+    from .client_reqrep import ConnectionKey
+    from .tracing import Trace
+
+
+class _DeprecationWaiter:
+    __slots__ = ("_awaitable", "_awaited")
+
+    def __init__(self, awaitable: Awaitable[Any]) -> None:
+        self._awaitable = awaitable
+        self._awaited = False
+
+    def __await__(self) -> Any:
+        self._awaited = True
+        return self._awaitable.__await__()
+
+    def __del__(self) -> None:
+        if not self._awaited:
+            warnings.warn(
+                "Connector.close() is a coroutine, "
+                "please use await connector.close()",
+                DeprecationWarning,
+            )
+
+
+class Connection:
+
+    _source_traceback = None
+    _transport = None
+
+    def __init__(
+        self,
+        connector: "BaseConnector",
+        key: "ConnectionKey",
+        protocol: ResponseHandler,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        self._key = key
+        self._connector = connector
+        self._loop = loop
+        self._protocol: Optional[ResponseHandler] = protocol
+        self._callbacks: List[Callable[[], None]] = []
+
+        if loop.get_debug():
+            self._source_traceback = traceback.extract_stack(sys._getframe(1))
+
+    def __repr__(self) -> str:
+        return f"Connection<{self._key}>"
+
+    def __del__(self, _warnings: Any = warnings) -> None:
+        if self._protocol is not None:
+            kwargs = {"source": self}
+            _warnings.warn(f"Unclosed connection {self!r}", ResourceWarning, **kwargs)
+            if self._loop.is_closed():
+                return
+
+            self._connector._release(self._key, self._protocol, should_close=True)
+
+            context = {"client_connection": self, "message": "Unclosed connection"}
+            if self._source_traceback is not None:
+                context["source_traceback"] = self._source_traceback
+            self._loop.call_exception_handler(context)
+
+    def __bool__(self) -> Literal[True]:
+        """Force subclasses to not be falsy, to make checks simpler."""
+        return True
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop:
+        warnings.warn(
+            "connector.loop property is deprecated", DeprecationWarning, stacklevel=2
+        )
+        return self._loop
+
+    @property
+    def transport(self) -> Optional[asyncio.Transport]:
+        if self._protocol is None:
+            return None
+        return self._protocol.transport
+
+    @property
+    def protocol(self) -> Optional[ResponseHandler]:
+        return self._protocol
+
+    def add_callback(self, callback: Callable[[], None]) -> None:
+        if callback is not None:
+            self._callbacks.append(callback)
+
+    def _notify_release(self) -> None:
+        callbacks, self._callbacks = self._callbacks[:], []
+
+        for cb in callbacks:
+            with suppress(Exception):
+                cb()
+
+    def close(self) -> None:
+        self._notify_release()
+
+        if self._protocol is not None:
+            self._connector._release(self._key, self._protocol, should_close=True)
+            self._protocol = None
+
+    def release(self) -> None:
+        self._notify_release()
+
+        if self._protocol is not None:
+            self._connector._release(
+                self._key, self._protocol, should_close=self._protocol.should_close
+            )
+            self._protocol = None
+
+    @property
+    def closed(self) -> bool:
+        return self._protocol is None or not self._protocol.is_connected()
+
+
+class _TransportPlaceholder:
+    """placeholder for BaseConnector.connect function"""
+
+    def close(self) -> None:
+        pass
+
+
+class BaseConnector:
+    """Base connector class.
+
+    keepalive_timeout - (optional) Keep-alive timeout.
+    force_close - Set to True to force close and do reconnect
+        after each request (and between redirects).
+    limit - The total number of simultaneous connections.
+    limit_per_host - Number of simultaneous connections to one host.
+    enable_cleanup_closed - Enables clean-up closed ssl transports.
+                            Disabled by default.
+    timeout_ceil_threshold - Trigger ceiling of timeout values when
+                             it's above timeout_ceil_threshold.
+    loop - Optional event loop.
+    """
+
+    _closed = True  # prevent AttributeError in __del__ if ctor was failed
+    _source_traceback = None
+
+    # abort transport after 2 seconds (cleanup broken connections)
+    _cleanup_closed_period = 2.0
+
+    def __init__(
+        self,
+        *,
+        keepalive_timeout: Union[object, None, float] = sentinel,
+        force_close: bool = False,
+        limit: int = 100,
+        limit_per_host: int = 0,
+        enable_cleanup_closed: bool = False,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        timeout_ceil_threshold: float = 5,
+    ) -> None:
+
+        if force_close:
+            if keepalive_timeout is not None and keepalive_timeout is not sentinel:
+                raise ValueError(
+                    "keepalive_timeout cannot " "be set if force_close is True"
+                )
+        else:
+            if keepalive_timeout is sentinel:
+                keepalive_timeout = 15.0
+
+        loop = get_running_loop(loop)
+        self._timeout_ceil_threshold = timeout_ceil_threshold
+
+        self._closed = False
+        if loop.get_debug():
+            self._source_traceback = traceback.extract_stack(sys._getframe(1))
+
+        self._conns: Dict[ConnectionKey, List[Tuple[ResponseHandler, float]]] = {}
+        self._limit = limit
+        self._limit_per_host = limit_per_host
+        self._acquired: Set[ResponseHandler] = set()
+        self._acquired_per_host: DefaultDict[
+            ConnectionKey, Set[ResponseHandler]
+        ] = defaultdict(set)
+        self._keepalive_timeout = cast(float, keepalive_timeout)
+        self._force_close = force_close
+
+        # {host_key: FIFO list of waiters}
+        self._waiters = defaultdict(deque)  # type: ignore[var-annotated]
+
+        self._loop = loop
+        self._factory = functools.partial(ResponseHandler, loop=loop)
+
+        self.cookies = SimpleCookie()
+
+        # start keep-alive connection cleanup task
+        self._cleanup_handle: Optional[asyncio.TimerHandle] = None
+
+        # start cleanup closed transports task
+        self._cleanup_closed_handle: Optional[asyncio.TimerHandle] = None
+        self._cleanup_closed_disabled = not enable_cleanup_closed
+        self._cleanup_closed_transports: List[Optional[asyncio.Transport]] = []
+        self._cleanup_closed()
+
+    def __del__(self, _warnings: Any = warnings) -> None:
+        if self._closed:
+            return
+        if not self._conns:
+            return
+
+        conns = [repr(c) for c in self._conns.values()]
+
+        self._close()
+
+        kwargs = {"source": self}
+        _warnings.warn(f"Unclosed connector {self!r}", ResourceWarning, **kwargs)
+        context = {
+            "connector": self,
+            "connections": conns,
+            "message": "Unclosed connector",
+        }
+        if self._source_traceback is not None:
+            context["source_traceback"] = self._source_traceback
+        self._loop.call_exception_handler(context)
+
+    def __enter__(self) -> "BaseConnector":
+        warnings.warn(
+            '"with Connector():" is deprecated, '
+            'use "async with Connector():" instead',
+            DeprecationWarning,
+        )
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self._close()
+
+    async def __aenter__(self) -> "BaseConnector":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        exc_traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.close()
+
+    @property
+    def force_close(self) -> bool:
+        """Ultimately close connection on releasing if True."""
+        return self._force_close
+
+    @property
+    def limit(self) -> int:
+        """The total number for simultaneous connections.
+
+        If limit is 0 the connector has no limit.
+        The default limit size is 100.
+        """
+        return self._limit
+
+    @property
+    def limit_per_host(self) -> int:
+        """The limit for simultaneous connections to the same endpoint.
+
+        Endpoints are the same if they are have equal
+        (host, port, is_ssl) triple.
+        """
+        return self._limit_per_host
+
+    def _cleanup(self) -> None:
+        """Cleanup unused transports."""
+        if self._cleanup_handle:
+            self._cleanup_handle.cancel()
+            # _cleanup_handle should be unset, otherwise _release() will not
+            # recreate it ever!
+            self._cleanup_handle = None
+
+        now = self._loop.time()
+        timeout = self._keepalive_timeout
+
+        if self._conns:
+            connections = {}
+            deadline = now - timeout
+            for key, conns in self._conns.items():
+                alive = []
+                for proto, use_time in conns:
+                    if proto.is_connected():
+                        if use_time - deadline < 0:
+                            transport = proto.transport
+                            proto.close()
+                            if key.is_ssl and not self._cleanup_closed_disabled:
+                                self._cleanup_closed_transports.append(transport)
+                        else:
+                            alive.append((proto, use_time))
+                    else:
+                        transport = proto.transport
+                        proto.close()
+                        if key.is_ssl and not self._cleanup_closed_disabled:
+                            self._cleanup_closed_transports.append(transport)
+
+                if alive:
+                    connections[key] = alive
+
+            self._conns = connections
+
+        if self._conns:
+            self._cleanup_handle = helpers.weakref_handle(
+                self,
+                "_cleanup",
+                timeout,
+                self._loop,
+                timeout_ceil_threshold=self._timeout_ceil_threshold,
+            )
+
+    def _drop_acquired_per_host(
+        self, key: "ConnectionKey", val: ResponseHandler
+    ) -> None:
+        acquired_per_host = self._acquired_per_host
+        if key not in acquired_per_host:
+            return
+        conns = acquired_per_host[key]
+        conns.remove(val)
+        if not conns:
+            del self._acquired_per_host[key]
+
+    def _cleanup_closed(self) -> None:
+        """Double confirmation for transport close.
+
+        Some broken ssl servers may leave socket open without proper close.
+        """
+        if self._cleanup_closed_handle:
+            self._cleanup_closed_handle.cancel()
+
+        for transport in self._cleanup_closed_transports:
+            if transport is not None:
+                transport.abort()
+
+        self._cleanup_closed_transports = []
+
+        if not self._cleanup_closed_disabled:
+            self._cleanup_closed_handle = helpers.weakref_handle(
+                self,
+                "_cleanup_closed",
+                self._cleanup_closed_period,
+                self._loop,
+                timeout_ceil_threshold=self._timeout_ceil_threshold,
+            )
+
+    def close(self) -> Awaitable[None]:
+        """Close all opened transports."""
+        self._close()
+        return _DeprecationWaiter(noop())
+
+    def _close(self) -> None:
+        if self._closed:
+            return
+
+        self._closed = True
+
+        try:
+            if self._loop.is_closed():
+                return
+
+            # cancel cleanup task
+            if self._cleanup_handle:
+                self._cleanup_handle.cancel()
+
+            # cancel cleanup close task
+            if self._cleanup_closed_handle:
+                self._cleanup_closed_handle.cancel()
+
+            for data in self._conns.values():
+                for proto, t0 in data:
+                    proto.close()
+
+            for proto in self._acquired:
+                proto.close()
+
+            for transport in self._cleanup_closed_transports:
+                if transport is not None:
+                    transport.abort()
+
+        finally:
+            self._conns.clear()
+            self._acquired.clear()
+            self._waiters.clear()
+            self._cleanup_handle = None
+            self._cleanup_closed_transports.clear()
+            self._cleanup_closed_handle = None
+
+    @property
+    def closed(self) -> bool:
+        """Is connector closed.
+
+        A readonly property.
+        """
+        return self._closed
+
+    def _available_connections(self, key: "ConnectionKey") -> int:
+        """
+        Return number of available connections.
+
+        The limit, limit_per_host and the connection key are taken into account.
+
+        If it returns less than 1 means that there are no connections
+        available.
+        """
+        if self._limit:
+            # total calc available connections
+            available = self._limit - len(self._acquired)
+
+            # check limit per host
+            if (
+                self._limit_per_host
+                and available > 0
+                and key in self._acquired_per_host
+            ):
+                acquired = self._acquired_per_host.get(key)
+                assert acquired is not None
+                available = self._limit_per_host - len(acquired)
+
+        elif self._limit_per_host and key in self._acquired_per_host:
+            # check limit per host
+            acquired = self._acquired_per_host.get(key)
+            assert acquired is not None
+            available = self._limit_per_host - len(acquired)
+        else:
+            available = 1
+
+        return available
+
+    async def connect(
+        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
+    ) -> Connection:
+        """Get from pool or create new connection."""
+        key = req.connection_key
+        available = self._available_connections(key)
+
+        # Wait if there are no available connections or if there are/were
+        # waiters (i.e. don't steal connection from a waiter about to wake up)
+        if available <= 0 or key in self._waiters:
+            fut = self._loop.create_future()
+
+            # This connection will now count towards the limit.
+            self._waiters[key].append(fut)
+
+            if traces:
+                for trace in traces:
+                    await trace.send_connection_queued_start()
+
+            try:
+                await fut
+            except BaseException as e:
+                if key in self._waiters:
+                    # remove a waiter even if it was cancelled, normally it's
+                    #  removed when it's notified
+                    try:
+                        self._waiters[key].remove(fut)
+                    except ValueError:  # fut may no longer be in list
+                        pass
+
+                raise e
+            finally:
+                if key in self._waiters and not self._waiters[key]:
+                    del self._waiters[key]
+
+            if traces:
+                for trace in traces:
+                    await trace.send_connection_queued_end()
+
+        proto = self._get(key)
+        if proto is None:
+            placeholder = cast(ResponseHandler, _TransportPlaceholder())
+            self._acquired.add(placeholder)
+            self._acquired_per_host[key].add(placeholder)
+
+            if traces:
+                for trace in traces:
+                    await trace.send_connection_create_start()
+
+            try:
+                proto = await self._create_connection(req, traces, timeout)
+                if self._closed:
+                    proto.close()
+                    raise ClientConnectionError("Connector is closed.")
+            except BaseException:
+                if not self._closed:
+                    self._acquired.remove(placeholder)
+                    self._drop_acquired_per_host(key, placeholder)
+                    self._release_waiter()
+                raise
+            else:
+                if not self._closed:
+                    self._acquired.remove(placeholder)
+                    self._drop_acquired_per_host(key, placeholder)
+
+            if traces:
+                for trace in traces:
+                    await trace.send_connection_create_end()
+        else:
+            if traces:
+                # Acquire the connection to prevent race conditions with limits
+                placeholder = cast(ResponseHandler, _TransportPlaceholder())
+                self._acquired.add(placeholder)
+                self._acquired_per_host[key].add(placeholder)
+                for trace in traces:
+                    await trace.send_connection_reuseconn()
+                self._acquired.remove(placeholder)
+                self._drop_acquired_per_host(key, placeholder)
+
+        self._acquired.add(proto)
+        self._acquired_per_host[key].add(proto)
+        return Connection(self, key, proto, self._loop)
+
+    def _get(self, key: "ConnectionKey") -> Optional[ResponseHandler]:
+        try:
+            conns = self._conns[key]
+        except KeyError:
+            return None
+
+        t1 = self._loop.time()
+        while conns:
+            proto, t0 = conns.pop()
+            if proto.is_connected():
+                if t1 - t0 > self._keepalive_timeout:
+                    transport = proto.transport
+                    proto.close()
+                    # only for SSL transports
+                    if key.is_ssl and not self._cleanup_closed_disabled:
+                        self._cleanup_closed_transports.append(transport)
+                else:
+                    if not conns:
+                        # The very last connection was reclaimed: drop the key
+                        del self._conns[key]
+                    return proto
+            else:
+                transport = proto.transport
+                proto.close()
+                if key.is_ssl and not self._cleanup_closed_disabled:
+                    self._cleanup_closed_transports.append(transport)
+
+        # No more connections: drop the key
+        del self._conns[key]
+        return None
+
+    def _release_waiter(self) -> None:
+        """
+        Iterates over all waiters until one to be released is found.
+
+        The one to be released is not finished and
+        belongs to a host that has available connections.
+        """
+        if not self._waiters:
+            return
+
+        # Having the dict keys ordered this avoids to iterate
+        # at the same order at each call.
+        queues = list(self._waiters.keys())
+        random.shuffle(queues)
+
+        for key in queues:
+            if self._available_connections(key) < 1:
+                continue
+
+            waiters = self._waiters[key]
+            while waiters:
+                waiter = waiters.popleft()
+                if not waiter.done():
+                    waiter.set_result(None)
+                    return
+
+    def _release_acquired(self, key: "ConnectionKey", proto: ResponseHandler) -> None:
+        if self._closed:
+            # acquired connection is already released on connector closing
+            return
+
+        try:
+            self._acquired.remove(proto)
+            self._drop_acquired_per_host(key, proto)
+        except KeyError:  # pragma: no cover
+            # this may be result of undetermenistic order of objects
+            # finalization due garbage collection.
+            pass
+        else:
+            self._release_waiter()
+
+    def _release(
+        self,
+        key: "ConnectionKey",
+        protocol: ResponseHandler,
+        *,
+        should_close: bool = False,
+    ) -> None:
+        if self._closed:
+            # acquired connection is already released on connector closing
+            return
+
+        self._release_acquired(key, protocol)
+
+        if self._force_close:
+            should_close = True
+
+        if should_close or protocol.should_close:
+            transport = protocol.transport
+            protocol.close()
+
+            if key.is_ssl and not self._cleanup_closed_disabled:
+                self._cleanup_closed_transports.append(transport)
+        else:
+            conns = self._conns.get(key)
+            if conns is None:
+                conns = self._conns[key] = []
+            conns.append((protocol, self._loop.time()))
+
+            if self._cleanup_handle is None:
+                self._cleanup_handle = helpers.weakref_handle(
+                    self,
+                    "_cleanup",
+                    self._keepalive_timeout,
+                    self._loop,
+                    timeout_ceil_threshold=self._timeout_ceil_threshold,
+                )
+
+    async def _create_connection(
+        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
+    ) -> ResponseHandler:
+        raise NotImplementedError()
+
+
+class _DNSCacheTable:
+    def __init__(self, ttl: Optional[float] = None) -> None:
+        self._addrs_rr: Dict[Tuple[str, int], Tuple[Iterator[Dict[str, Any]], int]] = {}
+        self._timestamps: Dict[Tuple[str, int], float] = {}
+        self._ttl = ttl
+
+    def __contains__(self, host: object) -> bool:
+        return host in self._addrs_rr
+
+    def add(self, key: Tuple[str, int], addrs: List[Dict[str, Any]]) -> None:
+        self._addrs_rr[key] = (cycle(addrs), len(addrs))
+
+        if self._ttl is not None:
+            self._timestamps[key] = monotonic()
+
+    def remove(self, key: Tuple[str, int]) -> None:
+        self._addrs_rr.pop(key, None)
+
+        if self._ttl is not None:
+            self._timestamps.pop(key, None)
+
+    def clear(self) -> None:
+        self._addrs_rr.clear()
+        self._timestamps.clear()
+
+    def next_addrs(self, key: Tuple[str, int]) -> List[Dict[str, Any]]:
+        loop, length = self._addrs_rr[key]
+        addrs = list(islice(loop, length))
+        # Consume one more element to shift internal state of `cycle`
+        next(loop)
+        return addrs
+
+    def expired(self, key: Tuple[str, int]) -> bool:
+        if self._ttl is None:
+            return False
+
+        return self._timestamps[key] + self._ttl < monotonic()
+
+
+class TCPConnector(BaseConnector):
+    """TCP connector.
+
+    verify_ssl - Set to True to check ssl certifications.
+    fingerprint - Pass the binary sha256
+        digest of the expected certificate in DER format to verify
+        that the certificate the server presents matches. See also
+        https://en.wikipedia.org/wiki/Transport_Layer_Security#Certificate_pinning
+    resolver - Enable DNS lookups and use this
+        resolver
+    use_dns_cache - Use memory cache for DNS lookups.
+    ttl_dns_cache - Max seconds having cached a DNS entry, None forever.
+    family - socket address family
+    local_addr - local tuple of (host, port) to bind socket to
+
+    keepalive_timeout - (optional) Keep-alive timeout.
+    force_close - Set to True to force close and do reconnect
+        after each request (and between redirects).
+    limit - The total number of simultaneous connections.
+    limit_per_host - Number of simultaneous connections to one host.
+    enable_cleanup_closed - Enables clean-up closed ssl transports.
+                            Disabled by default.
+    loop - Optional event loop.
+    """
+
+    def __init__(
+        self,
+        *,
+        verify_ssl: bool = True,
+        fingerprint: Optional[bytes] = None,
+        use_dns_cache: bool = True,
+        ttl_dns_cache: Optional[int] = 10,
+        family: int = 0,
+        ssl_context: Optional[SSLContext] = None,
+        ssl: Union[bool, Fingerprint, SSLContext] = True,
+        local_addr: Optional[Tuple[str, int]] = None,
+        resolver: Optional[AbstractResolver] = None,
+        keepalive_timeout: Union[None, float, object] = sentinel,
+        force_close: bool = False,
+        limit: int = 100,
+        limit_per_host: int = 0,
+        enable_cleanup_closed: bool = False,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        timeout_ceil_threshold: float = 5,
+    ):
+        super().__init__(
+            keepalive_timeout=keepalive_timeout,
+            force_close=force_close,
+            limit=limit,
+            limit_per_host=limit_per_host,
+            enable_cleanup_closed=enable_cleanup_closed,
+            loop=loop,
+            timeout_ceil_threshold=timeout_ceil_threshold,
+        )
+
+        self._ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint)
+        if resolver is None:
+            resolver = DefaultResolver(loop=self._loop)
+        self._resolver = resolver
+
+        self._use_dns_cache = use_dns_cache
+        self._cached_hosts = _DNSCacheTable(ttl=ttl_dns_cache)
+        self._throttle_dns_events: Dict[Tuple[str, int], EventResultOrError] = {}
+        self._family = family
+        self._local_addr = local_addr
+
+    def close(self) -> Awaitable[None]:
+        """Close all ongoing DNS calls."""
+        for ev in self._throttle_dns_events.values():
+            ev.cancel()
+
+        return super().close()
+
+    @property
+    def family(self) -> int:
+        """Socket family like AF_INET."""
+        return self._family
+
+    @property
+    def use_dns_cache(self) -> bool:
+        """True if local DNS caching is enabled."""
+        return self._use_dns_cache
+
+    def clear_dns_cache(
+        self, host: Optional[str] = None, port: Optional[int] = None
+    ) -> None:
+        """Remove specified host/port or clear all dns local cache."""
+        if host is not None and port is not None:
+            self._cached_hosts.remove((host, port))
+        elif host is not None or port is not None:
+            raise ValueError("either both host and port " "or none of them are allowed")
+        else:
+            self._cached_hosts.clear()
+
+    async def _resolve_host(
+        self, host: str, port: int, traces: Optional[List["Trace"]] = None
+    ) -> List[Dict[str, Any]]:
+        """Resolve host and return list of addresses."""
+        if is_ip_address(host):
+            return [
+                {
+                    "hostname": host,
+                    "host": host,
+                    "port": port,
+                    "family": self._family,
+                    "proto": 0,
+                    "flags": 0,
+                }
+            ]
+
+        if not self._use_dns_cache:
+
+            if traces:
+                for trace in traces:
+                    await trace.send_dns_resolvehost_start(host)
+
+            res = await self._resolver.resolve(host, port, family=self._family)
+
+            if traces:
+                for trace in traces:
+                    await trace.send_dns_resolvehost_end(host)
+
+            return res
+
+        key = (host, port)
+        if key in self._cached_hosts and not self._cached_hosts.expired(key):
+            # get result early, before any await (#4014)
+            result = self._cached_hosts.next_addrs(key)
+
+            if traces:
+                for trace in traces:
+                    await trace.send_dns_cache_hit(host)
+            return result
+
+        #
+        # If multiple connectors are resolving the same host, we wait
+        # for the first one to resolve and then use the result for all of them.
+        # We use a throttle event to ensure that we only resolve the host once
+        # and then use the result for all the waiters.
+        #
+        # In this case we need to create a task to ensure that we can shield
+        # the task from cancellation as cancelling this lookup should not cancel
+        # the underlying lookup or else the cancel event will get broadcast to
+        # all the waiters across all connections.
+        #
+        resolved_host_task = asyncio.create_task(
+            self._resolve_host_with_throttle(key, host, port, traces)
+        )
+        try:
+            return await asyncio.shield(resolved_host_task)
+        except asyncio.CancelledError:
+
+            def drop_exception(fut: "asyncio.Future[List[Dict[str, Any]]]") -> None:
+                with suppress(Exception, asyncio.CancelledError):
+                    fut.result()
+
+            resolved_host_task.add_done_callback(drop_exception)
+            raise
+
+    async def _resolve_host_with_throttle(
+        self,
+        key: Tuple[str, int],
+        host: str,
+        port: int,
+        traces: Optional[List["Trace"]],
+    ) -> List[Dict[str, Any]]:
+        """Resolve host with a dns events throttle."""
+        if key in self._throttle_dns_events:
+            # get event early, before any await (#4014)
+            event = self._throttle_dns_events[key]
+            if traces:
+                for trace in traces:
+                    await trace.send_dns_cache_hit(host)
+            await event.wait()
+        else:
+            # update dict early, before any await (#4014)
+            self._throttle_dns_events[key] = EventResultOrError(self._loop)
+            if traces:
+                for trace in traces:
+                    await trace.send_dns_cache_miss(host)
+            try:
+
+                if traces:
+                    for trace in traces:
+                        await trace.send_dns_resolvehost_start(host)
+
+                addrs = await self._resolver.resolve(host, port, family=self._family)
+                if traces:
+                    for trace in traces:
+                        await trace.send_dns_resolvehost_end(host)
+
+                self._cached_hosts.add(key, addrs)
+                self._throttle_dns_events[key].set()
+            except BaseException as e:
+                # any DNS exception, independently of the implementation
+                # is set for the waiters to raise the same exception.
+                self._throttle_dns_events[key].set(exc=e)
+                raise
+            finally:
+                self._throttle_dns_events.pop(key)
+
+        return self._cached_hosts.next_addrs(key)
+
+    async def _create_connection(
+        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
+    ) -> ResponseHandler:
+        """Create connection.
+
+        Has same keyword arguments as BaseEventLoop.create_connection.
+        """
+        if req.proxy:
+            _, proto = await self._create_proxy_connection(req, traces, timeout)
+        else:
+            _, proto = await self._create_direct_connection(req, traces, timeout)
+
+        return proto
+
+    @staticmethod
+    @functools.lru_cache(None)
+    def _make_ssl_context(verified: bool) -> SSLContext:
+        if verified:
+            return ssl.create_default_context()
+        else:
+            sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            sslcontext.options |= ssl.OP_NO_SSLv2
+            sslcontext.options |= ssl.OP_NO_SSLv3
+            sslcontext.check_hostname = False
+            sslcontext.verify_mode = ssl.CERT_NONE
+            try:
+                sslcontext.options |= ssl.OP_NO_COMPRESSION
+            except AttributeError as attr_err:
+                warnings.warn(
+                    "{!s}: The Python interpreter is compiled "
+                    "against OpenSSL < 1.0.0. Ref: "
+                    "https://docs.python.org/3/library/ssl.html"
+                    "#ssl.OP_NO_COMPRESSION".format(attr_err),
+                )
+            sslcontext.set_default_verify_paths()
+            return sslcontext
+
+    def _get_ssl_context(self, req: ClientRequest) -> Optional[SSLContext]:
+        """Logic to get the correct SSL context
+
+        0. if req.ssl is false, return None
+
+        1. if ssl_context is specified in req, use it
+        2. if _ssl_context is specified in self, use it
+        3. otherwise:
+            1. if verify_ssl is not specified in req, use self.ssl_context
+               (will generate a default context according to self.verify_ssl)
+            2. if verify_ssl is True in req, generate a default SSL context
+            3. if verify_ssl is False in req, generate a SSL context that
+               won't verify
+        """
+        if req.is_ssl():
+            if ssl is None:  # pragma: no cover
+                raise RuntimeError("SSL is not supported.")
+            sslcontext = req.ssl
+            if isinstance(sslcontext, ssl.SSLContext):
+                return sslcontext
+            if sslcontext is not True:
+                # not verified or fingerprinted
+                return self._make_ssl_context(False)
+            sslcontext = self._ssl
+            if isinstance(sslcontext, ssl.SSLContext):
+                return sslcontext
+            if sslcontext is not True:
+                # not verified or fingerprinted
+                return self._make_ssl_context(False)
+            return self._make_ssl_context(True)
+        else:
+            return None
+
+    def _get_fingerprint(self, req: ClientRequest) -> Optional["Fingerprint"]:
+        ret = req.ssl
+        if isinstance(ret, Fingerprint):
+            return ret
+        ret = self._ssl
+        if isinstance(ret, Fingerprint):
+            return ret
+        return None
+
+    async def _wrap_create_connection(
+        self,
+        *args: Any,
+        req: ClientRequest,
+        timeout: "ClientTimeout",
+        client_error: Type[Exception] = ClientConnectorError,
+        **kwargs: Any,
+    ) -> Tuple[asyncio.Transport, ResponseHandler]:
+        try:
+            async with ceil_timeout(
+                timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
+            ):
+                return await self._loop.create_connection(*args, **kwargs)
+        except cert_errors as exc:
+            raise ClientConnectorCertificateError(req.connection_key, exc) from exc
+        except ssl_errors as exc:
+            raise ClientConnectorSSLError(req.connection_key, exc) from exc
+        except OSError as exc:
+            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
+                raise
+            raise client_error(req.connection_key, exc) from exc
+
+    def _fail_on_no_start_tls(self, req: "ClientRequest") -> None:
+        """Raise a :py:exc:`RuntimeError` on missing ``start_tls()``.
+
+        It is necessary for TLS-in-TLS so that it is possible to
+        send HTTPS queries through HTTPS proxies.
+
+        This doesn't affect regular HTTP requests, though.
+        """
+        if not req.is_ssl():
+            return
+
+        proxy_url = req.proxy
+        assert proxy_url is not None
+        if proxy_url.scheme != "https":
+            return
+
+        self._check_loop_for_start_tls()
+
+    def _check_loop_for_start_tls(self) -> None:
+        try:
+            self._loop.start_tls
+        except AttributeError as attr_exc:
+            raise RuntimeError(
+                "An HTTPS request is being sent through an HTTPS proxy. "
+                "This needs support for TLS in TLS but it is not implemented "
+                "in your runtime for the stdlib asyncio.\n\n"
+                "Please upgrade to Python 3.11 or higher. For more details, "
+                "please see:\n"
+                "* https://bugs.python.org/issue37179\n"
+                "* https://github.com/python/cpython/pull/28073\n"
+                "* https://docs.aiohttp.org/en/stable/"
+                "client_advanced.html#proxy-support\n"
+                "* https://github.com/aio-libs/aiohttp/discussions/6044\n",
+            ) from attr_exc
+
+    def _loop_supports_start_tls(self) -> bool:
+        try:
+            self._check_loop_for_start_tls()
+        except RuntimeError:
+            return False
+        else:
+            return True
+
+    def _warn_about_tls_in_tls(
+        self,
+        underlying_transport: asyncio.Transport,
+        req: ClientRequest,
+    ) -> None:
+        """Issue a warning if the requested URL has HTTPS scheme."""
+        if req.request_info.url.scheme != "https":
+            return
+
+        asyncio_supports_tls_in_tls = getattr(
+            underlying_transport,
+            "_start_tls_compatible",
+            False,
+        )
+
+        if asyncio_supports_tls_in_tls:
+            return
+
+        warnings.warn(
+            "An HTTPS request is being sent through an HTTPS proxy. "
+            "This support for TLS in TLS is known to be disabled "
+            "in the stdlib asyncio (Python <3.11). This is why you'll probably see "
+            "an error in the log below.\n\n"
+            "It is possible to enable it via monkeypatching. "
+            "For more details, see:\n"
+            "* https://bugs.python.org/issue37179\n"
+            "* https://github.com/python/cpython/pull/28073\n\n"
+            "You can temporarily patch this as follows:\n"
+            "* https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support\n"
+            "* https://github.com/aio-libs/aiohttp/discussions/6044\n",
+            RuntimeWarning,
+            source=self,
+            # Why `4`? At least 3 of the calls in the stack originate
+            # from the methods in this class.
+            stacklevel=3,
+        )
+
+    async def _start_tls_connection(
+        self,
+        underlying_transport: asyncio.Transport,
+        req: ClientRequest,
+        timeout: "ClientTimeout",
+        client_error: Type[Exception] = ClientConnectorError,
+    ) -> Tuple[asyncio.BaseTransport, ResponseHandler]:
+        """Wrap the raw TCP transport with TLS."""
+        tls_proto = self._factory()  # Create a brand new proto for TLS
+
+        # Safety of the `cast()` call here is based on the fact that
+        # internally `_get_ssl_context()` only returns `None` when
+        # `req.is_ssl()` evaluates to `False` which is never gonna happen
+        # in this code path. Of course, it's rather fragile
+        # maintainability-wise but this is to be solved separately.
+        sslcontext = cast(ssl.SSLContext, self._get_ssl_context(req))
+
+        try:
+            async with ceil_timeout(
+                timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
+            ):
+                try:
+                    tls_transport = await self._loop.start_tls(
+                        underlying_transport,
+                        tls_proto,
+                        sslcontext,
+                        server_hostname=req.server_hostname or req.host,
+                        ssl_handshake_timeout=timeout.total,
+                    )
+                except BaseException:
+                    # We need to close the underlying transport since
+                    # `start_tls()` probably failed before it had a
+                    # chance to do this:
+                    underlying_transport.close()
+                    raise
+        except cert_errors as exc:
+            raise ClientConnectorCertificateError(req.connection_key, exc) from exc
+        except ssl_errors as exc:
+            raise ClientConnectorSSLError(req.connection_key, exc) from exc
+        except OSError as exc:
+            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
+                raise
+            raise client_error(req.connection_key, exc) from exc
+        except TypeError as type_err:
+            # Example cause looks like this:
+            # TypeError: transport <asyncio.sslproto._SSLProtocolTransport
+            # object at 0x7f760615e460> is not supported by start_tls()
+
+            raise ClientConnectionError(
+                "Cannot initialize a TLS-in-TLS connection to host "
+                f"{req.host!s}:{req.port:d} through an underlying connection "
+                f"to an HTTPS proxy {req.proxy!s} ssl:{req.ssl or 'default'} "
+                f"[{type_err!s}]"
+            ) from type_err
+        else:
+            if tls_transport is None:
+                msg = "Failed to start TLS (possibly caused by closing transport)"
+                raise client_error(req.connection_key, OSError(msg))
+            tls_proto.connection_made(
+                tls_transport
+            )  # Kick the state machine of the new TLS protocol
+
+        return tls_transport, tls_proto
+
+    async def _create_direct_connection(
+        self,
+        req: ClientRequest,
+        traces: List["Trace"],
+        timeout: "ClientTimeout",
+        *,
+        client_error: Type[Exception] = ClientConnectorError,
+    ) -> Tuple[asyncio.Transport, ResponseHandler]:
+        sslcontext = self._get_ssl_context(req)
+        fingerprint = self._get_fingerprint(req)
+
+        host = req.url.raw_host
+        assert host is not None
+        # Replace multiple trailing dots with a single one.
+        # A trailing dot is only present for fully-qualified domain names.
+        # See https://github.com/aio-libs/aiohttp/pull/7364.
+        if host.endswith(".."):
+            host = host.rstrip(".") + "."
+        port = req.port
+        assert port is not None
+        try:
+            # Cancelling this lookup should not cancel the underlying lookup
+            #  or else the cancel event will get broadcast to all the waiters
+            #  across all connections.
+            hosts = await self._resolve_host(host, port, traces=traces)
+        except OSError as exc:
+            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
+                raise
+            # in case of proxy it is not ClientProxyConnectionError
+            # it is problem of resolving proxy ip itself
+            raise ClientConnectorError(req.connection_key, exc) from exc
+
+        last_exc: Optional[Exception] = None
+
+        for hinfo in hosts:
+            host = hinfo["host"]
+            port = hinfo["port"]
+
+            # Strip trailing dots, certificates contain FQDN without dots.
+            # See https://github.com/aio-libs/aiohttp/issues/3636
+            server_hostname = (
+                (req.server_hostname or hinfo["hostname"]).rstrip(".")
+                if sslcontext
+                else None
+            )
+
+            try:
+                transp, proto = await self._wrap_create_connection(
+                    self._factory,
+                    host,
+                    port,
+                    timeout=timeout,
+                    ssl=sslcontext,
+                    family=hinfo["family"],
+                    proto=hinfo["proto"],
+                    flags=hinfo["flags"],
+                    server_hostname=server_hostname,
+                    local_addr=self._local_addr,
+                    req=req,
+                    client_error=client_error,
+                )
+            except ClientConnectorError as exc:
+                last_exc = exc
+                continue
+
+            if req.is_ssl() and fingerprint:
+                try:
+                    fingerprint.check(transp)
+                except ServerFingerprintMismatch as exc:
+                    transp.close()
+                    if not self._cleanup_closed_disabled:
+                        self._cleanup_closed_transports.append(transp)
+                    last_exc = exc
+                    continue
+
+            return transp, proto
+        else:
+            assert last_exc is not None
+            raise last_exc
+
+    async def _create_proxy_connection(
+        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
+    ) -> Tuple[asyncio.BaseTransport, ResponseHandler]:
+        self._fail_on_no_start_tls(req)
+        runtime_has_start_tls = self._loop_supports_start_tls()
+
+        headers: Dict[str, str] = {}
+        if req.proxy_headers is not None:
+            headers = req.proxy_headers  # type: ignore[assignment]
+        headers[hdrs.HOST] = req.headers[hdrs.HOST]
+
+        url = req.proxy
+        assert url is not None
+        proxy_req = ClientRequest(
+            hdrs.METH_GET,
+            url,
+            headers=headers,
+            auth=req.proxy_auth,
+            loop=self._loop,
+            ssl=req.ssl,
+        )
+
+        # create connection to proxy server
+        transport, proto = await self._create_direct_connection(
+            proxy_req, [], timeout, client_error=ClientProxyConnectionError
+        )
+
+        # Many HTTP proxies has buggy keepalive support.  Let's not
+        # reuse connection but close it after processing every
+        # response.
+        proto.force_close()
+
+        auth = proxy_req.headers.pop(hdrs.AUTHORIZATION, None)
+        if auth is not None:
+            if not req.is_ssl():
+                req.headers[hdrs.PROXY_AUTHORIZATION] = auth
+            else:
+                proxy_req.headers[hdrs.PROXY_AUTHORIZATION] = auth
+
+        if req.is_ssl():
+            if runtime_has_start_tls:
+                self._warn_about_tls_in_tls(transport, req)
+
+            # For HTTPS requests over HTTP proxy
+            # we must notify proxy to tunnel connection
+            # so we send CONNECT command:
+            #   CONNECT www.python.org:443 HTTP/1.1
+            #   Host: www.python.org
+            #
+            # next we must do TLS handshake and so on
+            # to do this we must wrap raw socket into secure one
+            # asyncio handles this perfectly
+            proxy_req.method = hdrs.METH_CONNECT
+            proxy_req.url = req.url
+            key = attr.evolve(
+                req.connection_key, proxy=None, proxy_auth=None, proxy_headers_hash=None
+            )
+            conn = Connection(self, key, proto, self._loop)
+            proxy_resp = await proxy_req.send(conn)
+            try:
+                protocol = conn._protocol
+                assert protocol is not None
+
+                # read_until_eof=True will ensure the connection isn't closed
+                # once the response is received and processed allowing
+                # START_TLS to work on the connection below.
+                protocol.set_response_params(
+                    read_until_eof=runtime_has_start_tls,
+                    timeout_ceil_threshold=self._timeout_ceil_threshold,
+                )
+                resp = await proxy_resp.start(conn)
+            except BaseException:
+                proxy_resp.close()
+                conn.close()
+                raise
+            else:
+                conn._protocol = None
+                conn._transport = None
+                try:
+                    if resp.status != 200:
+                        message = resp.reason
+                        if message is None:
+                            message = HTTPStatus(resp.status).phrase
+                        raise ClientHttpProxyError(
+                            proxy_resp.request_info,
+                            resp.history,
+                            status=resp.status,
+                            message=message,
+                            headers=resp.headers,
+                        )
+                    if not runtime_has_start_tls:
+                        rawsock = transport.get_extra_info("socket", default=None)
+                        if rawsock is None:
+                            raise RuntimeError(
+                                "Transport does not expose socket instance"
+                            )
+                        # Duplicate the socket, so now we can close proxy transport
+                        rawsock = rawsock.dup()
+                except BaseException:
+                    # It shouldn't be closed in `finally` because it's fed to
+                    # `loop.start_tls()` and the docs say not to touch it after
+                    # passing there.
+                    transport.close()
+                    raise
+                finally:
+                    if not runtime_has_start_tls:
+                        transport.close()
+
+                if not runtime_has_start_tls:
+                    # HTTP proxy with support for upgrade to HTTPS
+                    sslcontext = self._get_ssl_context(req)
+                    return await self._wrap_create_connection(
+                        self._factory,
+                        timeout=timeout,
+                        ssl=sslcontext,
+                        sock=rawsock,
+                        server_hostname=req.host,
+                        req=req,
+                    )
+
+                return await self._start_tls_connection(
+                    # Access the old transport for the last time before it's
+                    # closed and forgotten forever:
+                    transport,
+                    req=req,
+                    timeout=timeout,
+                )
+            finally:
+                proxy_resp.close()
+
+        return transport, proto
+
+
+class UnixConnector(BaseConnector):
+    """Unix socket connector.
+
+    path - Unix socket path.
+    keepalive_timeout - (optional) Keep-alive timeout.
+    force_close - Set to True to force close and do reconnect
+        after each request (and between redirects).
+    limit - The total number of simultaneous connections.
+    limit_per_host - Number of simultaneous connections to one host.
+    loop - Optional event loop.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        force_close: bool = False,
+        keepalive_timeout: Union[object, float, None] = sentinel,
+        limit: int = 100,
+        limit_per_host: int = 0,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        super().__init__(
+            force_close=force_close,
+            keepalive_timeout=keepalive_timeout,
+            limit=limit,
+            limit_per_host=limit_per_host,
+            loop=loop,
+        )
+        self._path = path
+
+    @property
+    def path(self) -> str:
+        """Path to unix socket."""
+        return self._path
+
+    async def _create_connection(
+        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
+    ) -> ResponseHandler:
+        try:
+            async with ceil_timeout(
+                timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
+            ):
+                _, proto = await self._loop.create_unix_connection(
+                    self._factory, self._path
+                )
+        except OSError as exc:
+            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
+                raise
+            raise UnixClientConnectorError(self.path, req.connection_key, exc) from exc
+
+        return proto
+
+
+class NamedPipeConnector(BaseConnector):
+    """Named pipe connector.
+
+    Only supported by the proactor event loop.
+    See also: https://docs.python.org/3/library/asyncio-eventloop.html
+
+    path - Windows named pipe path.
+    keepalive_timeout - (optional) Keep-alive timeout.
+    force_close - Set to True to force close and do reconnect
+        after each request (and between redirects).
+    limit - The total number of simultaneous connections.
+    limit_per_host - Number of simultaneous connections to one host.
+    loop - Optional event loop.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        force_close: bool = False,
+        keepalive_timeout: Union[object, float, None] = sentinel,
+        limit: int = 100,
+        limit_per_host: int = 0,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        super().__init__(
+            force_close=force_close,
+            keepalive_timeout=keepalive_timeout,
+            limit=limit,
+            limit_per_host=limit_per_host,
+            loop=loop,
+        )
+        if not isinstance(
+            self._loop, asyncio.ProactorEventLoop  # type: ignore[attr-defined]
+        ):
+            raise RuntimeError(
+                "Named Pipes only available in proactor " "loop under windows"
+            )
+        self._path = path
+
+    @property
+    def path(self) -> str:
+        """Path to the named pipe."""
+        return self._path
+
+    async def _create_connection(
+        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
+    ) -> ResponseHandler:
+        try:
+            async with ceil_timeout(
+                timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
+            ):
+                _, proto = await self._loop.create_pipe_connection(  # type: ignore[attr-defined]
+                    self._factory, self._path
+                )
+                # the drain is required so that the connection_made is called
+                # and transport is set otherwise it is not set before the
+                # `assert conn.transport is not None`
+                # in client.py's _request method
+                await asyncio.sleep(0)
+                # other option is to manually set transport like
+                # `proto.transport = trans`
+        except OSError as exc:
+            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
+                raise
+            raise ClientConnectorError(req.connection_key, exc) from exc
+
+        return cast(ResponseHandler, proto)

env-llmeval/lib/python3.10/site-packages/aiohttp/cookiejar.py

@@ -0,0 +1,419 @@
+import asyncio
+import calendar
+import contextlib
+import datetime
+import os  # noqa
+import pathlib
+import pickle
+import re
+import time
+from collections import defaultdict
+from http.cookies import BaseCookie, Morsel, SimpleCookie
+from math import ceil
+from typing import (  # noqa
+    DefaultDict,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
+
+from yarl import URL
+
+from .abc import AbstractCookieJar, ClearCookiePredicate
+from .helpers import is_ip_address
+from .typedefs import LooseCookies, PathLike, StrOrURL
+
+__all__ = ("CookieJar", "DummyCookieJar")
+
+
+CookieItem = Union[str, "Morsel[str]"]
+
+
+class CookieJar(AbstractCookieJar):
+    """Implements cookie storage adhering to RFC 6265."""
+
+    DATE_TOKENS_RE = re.compile(
+        r"[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]*"
+        r"(?P<token>[\x00-\x08\x0A-\x1F\d:a-zA-Z\x7F-\xFF]+)"
+    )
+
+    DATE_HMS_TIME_RE = re.compile(r"(\d{1,2}):(\d{1,2}):(\d{1,2})")
+
+    DATE_DAY_OF_MONTH_RE = re.compile(r"(\d{1,2})")
+
+    DATE_MONTH_RE = re.compile(
+        "(jan)|(feb)|(mar)|(apr)|(may)|(jun)|(jul)|" "(aug)|(sep)|(oct)|(nov)|(dec)",
+        re.I,
+    )
+
+    DATE_YEAR_RE = re.compile(r"(\d{2,4})")
+
+    # calendar.timegm() fails for timestamps after datetime.datetime.max
+    # Minus one as a loss of precision occurs when timestamp() is called.
+    MAX_TIME = (
+        int(datetime.datetime.max.replace(tzinfo=datetime.timezone.utc).timestamp()) - 1
+    )
+    try:
+        calendar.timegm(time.gmtime(MAX_TIME))
+    except (OSError, ValueError):
+        # Hit the maximum representable time on Windows
+        # https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/localtime-localtime32-localtime64
+        # Throws ValueError on PyPy 3.8 and 3.9, OSError elsewhere
+        MAX_TIME = calendar.timegm((3000, 12, 31, 23, 59, 59, -1, -1, -1))
+    except OverflowError:
+        # #4515: datetime.max may not be representable on 32-bit platforms
+        MAX_TIME = 2**31 - 1
+    # Avoid minuses in the future, 3x faster
+    SUB_MAX_TIME = MAX_TIME - 1
+
+    def __init__(
+        self,
+        *,
+        unsafe: bool = False,
+        quote_cookie: bool = True,
+        treat_as_secure_origin: Union[StrOrURL, List[StrOrURL], None] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        super().__init__(loop=loop)
+        self._cookies: DefaultDict[Tuple[str, str], SimpleCookie] = defaultdict(
+            SimpleCookie
+        )
+        self._host_only_cookies: Set[Tuple[str, str]] = set()
+        self._unsafe = unsafe
+        self._quote_cookie = quote_cookie
+        if treat_as_secure_origin is None:
+            treat_as_secure_origin = []
+        elif isinstance(treat_as_secure_origin, URL):
+            treat_as_secure_origin = [treat_as_secure_origin.origin()]
+        elif isinstance(treat_as_secure_origin, str):
+            treat_as_secure_origin = [URL(treat_as_secure_origin).origin()]
+        else:
+            treat_as_secure_origin = [
+                URL(url).origin() if isinstance(url, str) else url.origin()
+                for url in treat_as_secure_origin
+            ]
+        self._treat_as_secure_origin = treat_as_secure_origin
+        self._next_expiration: float = ceil(time.time())
+        self._expirations: Dict[Tuple[str, str, str], float] = {}
+
+    def save(self, file_path: PathLike) -> None:
+        file_path = pathlib.Path(file_path)
+        with file_path.open(mode="wb") as f:
+            pickle.dump(self._cookies, f, pickle.HIGHEST_PROTOCOL)
+
+    def load(self, file_path: PathLike) -> None:
+        file_path = pathlib.Path(file_path)
+        with file_path.open(mode="rb") as f:
+            self._cookies = pickle.load(f)
+
+    def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None:
+        if predicate is None:
+            self._next_expiration = ceil(time.time())
+            self._cookies.clear()
+            self._host_only_cookies.clear()
+            self._expirations.clear()
+            return
+
+        to_del = []
+        now = time.time()
+        for (domain, path), cookie in self._cookies.items():
+            for name, morsel in cookie.items():
+                key = (domain, path, name)
+                if (
+                    key in self._expirations and self._expirations[key] <= now
+                ) or predicate(morsel):
+                    to_del.append(key)
+
+        for domain, path, name in to_del:
+            self._host_only_cookies.discard((domain, name))
+            key = (domain, path, name)
+            if key in self._expirations:
+                del self._expirations[(domain, path, name)]
+            self._cookies[(domain, path)].pop(name, None)
+
+        self._next_expiration = (
+            min(*self._expirations.values(), self.SUB_MAX_TIME) + 1
+            if self._expirations
+            else self.MAX_TIME
+        )
+
+    def clear_domain(self, domain: str) -> None:
+        self.clear(lambda x: self._is_domain_match(domain, x["domain"]))
+
+    def __iter__(self) -> "Iterator[Morsel[str]]":
+        self._do_expiration()
+        for val in self._cookies.values():
+            yield from val.values()
+
+    def __len__(self) -> int:
+        return sum(1 for i in self)
+
+    def _do_expiration(self) -> None:
+        self.clear(lambda x: False)
+
+    def _expire_cookie(self, when: float, domain: str, path: str, name: str) -> None:
+        self._next_expiration = min(self._next_expiration, when)
+        self._expirations[(domain, path, name)] = when
+
+    def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None:
+        """Update cookies."""
+        hostname = response_url.raw_host
+
+        if not self._unsafe and is_ip_address(hostname):
+            # Don't accept cookies from IPs
+            return
+
+        if isinstance(cookies, Mapping):
+            cookies = cookies.items()
+
+        for name, cookie in cookies:
+            if not isinstance(cookie, Morsel):
+                tmp = SimpleCookie()
+                tmp[name] = cookie  # type: ignore[assignment]
+                cookie = tmp[name]
+
+            domain = cookie["domain"]
+
+            # ignore domains with trailing dots
+            if domain.endswith("."):
+                domain = ""
+                del cookie["domain"]
+
+            if not domain and hostname is not None:
+                # Set the cookie's domain to the response hostname
+                # and set its host-only-flag
+                self._host_only_cookies.add((hostname, name))
+                domain = cookie["domain"] = hostname
+
+            if domain.startswith("."):
+                # Remove leading dot
+                domain = domain[1:]
+                cookie["domain"] = domain
+
+            if hostname and not self._is_domain_match(domain, hostname):
+                # Setting cookies for different domains is not allowed
+                continue
+
+            path = cookie["path"]
+            if not path or not path.startswith("/"):
+                # Set the cookie's path to the response path
+                path = response_url.path
+                if not path.startswith("/"):
+                    path = "/"
+                else:
+                    # Cut everything from the last slash to the end
+                    path = "/" + path[1 : path.rfind("/")]
+                cookie["path"] = path
+
+            max_age = cookie["max-age"]
+            if max_age:
+                try:
+                    delta_seconds = int(max_age)
+                    max_age_expiration = min(time.time() + delta_seconds, self.MAX_TIME)
+                    self._expire_cookie(max_age_expiration, domain, path, name)
+                except ValueError:
+                    cookie["max-age"] = ""
+
+            else:
+                expires = cookie["expires"]
+                if expires:
+                    expire_time = self._parse_date(expires)
+                    if expire_time:
+                        self._expire_cookie(expire_time, domain, path, name)
+                    else:
+                        cookie["expires"] = ""
+
+            self._cookies[(domain, path)][name] = cookie
+
+        self._do_expiration()
+
+    def filter_cookies(self, request_url: URL = URL()) -> "BaseCookie[str]":
+        """Returns this jar's cookies filtered by their attributes."""
+        filtered: Union[SimpleCookie, "BaseCookie[str]"] = (
+            SimpleCookie() if self._quote_cookie else BaseCookie()
+        )
+        if not self._cookies:
+            # Skip do_expiration() if there are no cookies.
+            return filtered
+        self._do_expiration()
+        if not self._cookies:
+            # Skip rest of function if no non-expired cookies.
+            return filtered
+        request_url = URL(request_url)
+        hostname = request_url.raw_host or ""
+
+        is_not_secure = request_url.scheme not in ("https", "wss")
+        if is_not_secure and self._treat_as_secure_origin:
+            request_origin = URL()
+            with contextlib.suppress(ValueError):
+                request_origin = request_url.origin()
+            is_not_secure = request_origin not in self._treat_as_secure_origin
+
+        # Point 2: https://www.rfc-editor.org/rfc/rfc6265.html#section-5.4
+        for cookie in sorted(self, key=lambda c: len(c["path"])):
+            name = cookie.key
+            domain = cookie["domain"]
+
+            # Send shared cookies
+            if not domain:
+                filtered[name] = cookie.value
+                continue
+
+            if not self._unsafe and is_ip_address(hostname):
+                continue
+
+            if (domain, name) in self._host_only_cookies:
+                if domain != hostname:
+                    continue
+            elif not self._is_domain_match(domain, hostname):
+                continue
+
+            if not self._is_path_match(request_url.path, cookie["path"]):
+                continue
+
+            if is_not_secure and cookie["secure"]:
+                continue
+
+            # It's critical we use the Morsel so the coded_value
+            # (based on cookie version) is preserved
+            mrsl_val = cast("Morsel[str]", cookie.get(cookie.key, Morsel()))
+            mrsl_val.set(cookie.key, cookie.value, cookie.coded_value)
+            filtered[name] = mrsl_val
+
+        return filtered
+
+    @staticmethod
+    def _is_domain_match(domain: str, hostname: str) -> bool:
+        """Implements domain matching adhering to RFC 6265."""
+        if hostname == domain:
+            return True
+
+        if not hostname.endswith(domain):
+            return False
+
+        non_matching = hostname[: -len(domain)]
+
+        if not non_matching.endswith("."):
+            return False
+
+        return not is_ip_address(hostname)
+
+    @staticmethod
+    def _is_path_match(req_path: str, cookie_path: str) -> bool:
+        """Implements path matching adhering to RFC 6265."""
+        if not req_path.startswith("/"):
+            req_path = "/"
+
+        if req_path == cookie_path:
+            return True
+
+        if not req_path.startswith(cookie_path):
+            return False
+
+        if cookie_path.endswith("/"):
+            return True
+
+        non_matching = req_path[len(cookie_path) :]
+
+        return non_matching.startswith("/")
+
+    @classmethod
+    def _parse_date(cls, date_str: str) -> Optional[int]:
+        """Implements date string parsing adhering to RFC 6265."""
+        if not date_str:
+            return None
+
+        found_time = False
+        found_day = False
+        found_month = False
+        found_year = False
+
+        hour = minute = second = 0
+        day = 0
+        month = 0
+        year = 0
+
+        for token_match in cls.DATE_TOKENS_RE.finditer(date_str):
+
+            token = token_match.group("token")
+
+            if not found_time:
+                time_match = cls.DATE_HMS_TIME_RE.match(token)
+                if time_match:
+                    found_time = True
+                    hour, minute, second = (int(s) for s in time_match.groups())
+                    continue
+
+            if not found_day:
+                day_match = cls.DATE_DAY_OF_MONTH_RE.match(token)
+                if day_match:
+                    found_day = True
+                    day = int(day_match.group())
+                    continue
+
+            if not found_month:
+                month_match = cls.DATE_MONTH_RE.match(token)
+                if month_match:
+                    found_month = True
+                    assert month_match.lastindex is not None
+                    month = month_match.lastindex
+                    continue
+
+            if not found_year:
+                year_match = cls.DATE_YEAR_RE.match(token)
+                if year_match:
+                    found_year = True
+                    year = int(year_match.group())
+
+        if 70 <= year <= 99:
+            year += 1900
+        elif 0 <= year <= 69:
+            year += 2000
+
+        if False in (found_day, found_month, found_year, found_time):
+            return None
+
+        if not 1 <= day <= 31:
+            return None
+
+        if year < 1601 or hour > 23 or minute > 59 or second > 59:
+            return None
+
+        return calendar.timegm((year, month, day, hour, minute, second, -1, -1, -1))
+
+
+class DummyCookieJar(AbstractCookieJar):
+    """Implements a dummy cookie storage.
+
+    It can be used with the ClientSession when no cookie processing is needed.
+
+    """
+
+    def __init__(self, *, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
+        super().__init__(loop=loop)
+
+    def __iter__(self) -> "Iterator[Morsel[str]]":
+        while False:
+            yield None
+
+    def __len__(self) -> int:
+        return 0
+
+    def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None:
+        pass
+
+    def clear_domain(self, domain: str) -> None:
+        pass
+
+    def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None:
+        pass
+
+    def filter_cookies(self, request_url: URL) -> "BaseCookie[str]":
+        return SimpleCookie()

env-llmeval/lib/python3.10/site-packages/aiohttp/formdata.py

@@ -0,0 +1,182 @@
+import io
+import warnings
+from typing import Any, Iterable, List, Optional
+from urllib.parse import urlencode
+
+from multidict import MultiDict, MultiDictProxy
+
+from . import hdrs, multipart, payload
+from .helpers import guess_filename
+from .payload import Payload
+
+__all__ = ("FormData",)
+
+
+class FormData:
+    """Helper class for form body generation.
+
+    Supports multipart/form-data and application/x-www-form-urlencoded.
+    """
+
+    def __init__(
+        self,
+        fields: Iterable[Any] = (),
+        quote_fields: bool = True,
+        charset: Optional[str] = None,
+    ) -> None:
+        self._writer = multipart.MultipartWriter("form-data")
+        self._fields: List[Any] = []
+        self._is_multipart = False
+        self._is_processed = False
+        self._quote_fields = quote_fields
+        self._charset = charset
+
+        if isinstance(fields, dict):
+            fields = list(fields.items())
+        elif not isinstance(fields, (list, tuple)):
+            fields = (fields,)
+        self.add_fields(*fields)
+
+    @property
+    def is_multipart(self) -> bool:
+        return self._is_multipart
+
+    def add_field(
+        self,
+        name: str,
+        value: Any,
+        *,
+        content_type: Optional[str] = None,
+        filename: Optional[str] = None,
+        content_transfer_encoding: Optional[str] = None,
+    ) -> None:
+
+        if isinstance(value, io.IOBase):
+            self._is_multipart = True
+        elif isinstance(value, (bytes, bytearray, memoryview)):
+            msg = (
+                "In v4, passing bytes will no longer create a file field. "
+                "Please explicitly use the filename parameter or pass a BytesIO object."
+            )
+            if filename is None and content_transfer_encoding is None:
+                warnings.warn(msg, DeprecationWarning)
+                filename = name
+
+        type_options: MultiDict[str] = MultiDict({"name": name})
+        if filename is not None and not isinstance(filename, str):
+            raise TypeError(
+                "filename must be an instance of str. " "Got: %s" % filename
+            )
+        if filename is None and isinstance(value, io.IOBase):
+            filename = guess_filename(value, name)
+        if filename is not None:
+            type_options["filename"] = filename
+            self._is_multipart = True
+
+        headers = {}
+        if content_type is not None:
+            if not isinstance(content_type, str):
+                raise TypeError(
+                    "content_type must be an instance of str. " "Got: %s" % content_type
+                )
+            headers[hdrs.CONTENT_TYPE] = content_type
+            self._is_multipart = True
+        if content_transfer_encoding is not None:
+            if not isinstance(content_transfer_encoding, str):
+                raise TypeError(
+                    "content_transfer_encoding must be an instance"
+                    " of str. Got: %s" % content_transfer_encoding
+                )
+            msg = (
+                "content_transfer_encoding is deprecated. "
+                "To maintain compatibility with v4 please pass a BytesPayload."
+            )
+            warnings.warn(msg, DeprecationWarning)
+            self._is_multipart = True
+
+        self._fields.append((type_options, headers, value))
+
+    def add_fields(self, *fields: Any) -> None:
+        to_add = list(fields)
+
+        while to_add:
+            rec = to_add.pop(0)
+
+            if isinstance(rec, io.IOBase):
+                k = guess_filename(rec, "unknown")
+                self.add_field(k, rec)  # type: ignore[arg-type]
+
+            elif isinstance(rec, (MultiDictProxy, MultiDict)):
+                to_add.extend(rec.items())
+
+            elif isinstance(rec, (list, tuple)) and len(rec) == 2:
+                k, fp = rec
+                self.add_field(k, fp)  # type: ignore[arg-type]
+
+            else:
+                raise TypeError(
+                    "Only io.IOBase, multidict and (name, file) "
+                    "pairs allowed, use .add_field() for passing "
+                    "more complex parameters, got {!r}".format(rec)
+                )
+
+    def _gen_form_urlencoded(self) -> payload.BytesPayload:
+        # form data (x-www-form-urlencoded)
+        data = []
+        for type_options, _, value in self._fields:
+            data.append((type_options["name"], value))
+
+        charset = self._charset if self._charset is not None else "utf-8"
+
+        if charset == "utf-8":
+            content_type = "application/x-www-form-urlencoded"
+        else:
+            content_type = "application/x-www-form-urlencoded; " "charset=%s" % charset
+
+        return payload.BytesPayload(
+            urlencode(data, doseq=True, encoding=charset).encode(),
+            content_type=content_type,
+        )
+
+    def _gen_form_data(self) -> multipart.MultipartWriter:
+        """Encode a list of fields using the multipart/form-data MIME format"""
+        if self._is_processed:
+            raise RuntimeError("Form data has been processed already")
+        for dispparams, headers, value in self._fields:
+            try:
+                if hdrs.CONTENT_TYPE in headers:
+                    part = payload.get_payload(
+                        value,
+                        content_type=headers[hdrs.CONTENT_TYPE],
+                        headers=headers,
+                        encoding=self._charset,
+                    )
+                else:
+                    part = payload.get_payload(
+                        value, headers=headers, encoding=self._charset
+                    )
+            except Exception as exc:
+                raise TypeError(
+                    "Can not serialize value type: %r\n "
+                    "headers: %r\n value: %r" % (type(value), headers, value)
+                ) from exc
+
+            if dispparams:
+                part.set_content_disposition(
+                    "form-data", quote_fields=self._quote_fields, **dispparams
+                )
+                # FIXME cgi.FieldStorage doesn't likes body parts with
+                # Content-Length which were sent via chunked transfer encoding
+                assert part.headers is not None
+                part.headers.popall(hdrs.CONTENT_LENGTH, None)
+
+            self._writer.append_payload(part)
+
+        self._is_processed = True
+        return self._writer
+
+    def __call__(self) -> Payload:
+        if self._is_multipart:
+            return self._gen_form_data()
+        else:
+            return self._gen_form_urlencoded()

env-llmeval/lib/python3.10/site-packages/aiohttp/hdrs.py

@@ -0,0 +1,108 @@
+"""HTTP Headers constants."""
+
+# After changing the file content call ./tools/gen.py
+# to regenerate the headers parser
+from typing import Final, Set
+
+from multidict import istr
+
+METH_ANY: Final[str] = "*"
+METH_CONNECT: Final[str] = "CONNECT"
+METH_HEAD: Final[str] = "HEAD"
+METH_GET: Final[str] = "GET"
+METH_DELETE: Final[str] = "DELETE"
+METH_OPTIONS: Final[str] = "OPTIONS"
+METH_PATCH: Final[str] = "PATCH"
+METH_POST: Final[str] = "POST"
+METH_PUT: Final[str] = "PUT"
+METH_TRACE: Final[str] = "TRACE"
+
+METH_ALL: Final[Set[str]] = {
+    METH_CONNECT,
+    METH_HEAD,
+    METH_GET,
+    METH_DELETE,
+    METH_OPTIONS,
+    METH_PATCH,
+    METH_POST,
+    METH_PUT,
+    METH_TRACE,
+}
+
+ACCEPT: Final[istr] = istr("Accept")
+ACCEPT_CHARSET: Final[istr] = istr("Accept-Charset")
+ACCEPT_ENCODING: Final[istr] = istr("Accept-Encoding")
+ACCEPT_LANGUAGE: Final[istr] = istr("Accept-Language")
+ACCEPT_RANGES: Final[istr] = istr("Accept-Ranges")
+ACCESS_CONTROL_MAX_AGE: Final[istr] = istr("Access-Control-Max-Age")
+ACCESS_CONTROL_ALLOW_CREDENTIALS: Final[istr] = istr("Access-Control-Allow-Credentials")
+ACCESS_CONTROL_ALLOW_HEADERS: Final[istr] = istr("Access-Control-Allow-Headers")
+ACCESS_CONTROL_ALLOW_METHODS: Final[istr] = istr("Access-Control-Allow-Methods")
+ACCESS_CONTROL_ALLOW_ORIGIN: Final[istr] = istr("Access-Control-Allow-Origin")
+ACCESS_CONTROL_EXPOSE_HEADERS: Final[istr] = istr("Access-Control-Expose-Headers")
+ACCESS_CONTROL_REQUEST_HEADERS: Final[istr] = istr("Access-Control-Request-Headers")
+ACCESS_CONTROL_REQUEST_METHOD: Final[istr] = istr("Access-Control-Request-Method")
+AGE: Final[istr] = istr("Age")
+ALLOW: Final[istr] = istr("Allow")
+AUTHORIZATION: Final[istr] = istr("Authorization")
+CACHE_CONTROL: Final[istr] = istr("Cache-Control")
+CONNECTION: Final[istr] = istr("Connection")
+CONTENT_DISPOSITION: Final[istr] = istr("Content-Disposition")
+CONTENT_ENCODING: Final[istr] = istr("Content-Encoding")
+CONTENT_LANGUAGE: Final[istr] = istr("Content-Language")
+CONTENT_LENGTH: Final[istr] = istr("Content-Length")
+CONTENT_LOCATION: Final[istr] = istr("Content-Location")
+CONTENT_MD5: Final[istr] = istr("Content-MD5")
+CONTENT_RANGE: Final[istr] = istr("Content-Range")
+CONTENT_TRANSFER_ENCODING: Final[istr] = istr("Content-Transfer-Encoding")
+CONTENT_TYPE: Final[istr] = istr("Content-Type")
+COOKIE: Final[istr] = istr("Cookie")
+DATE: Final[istr] = istr("Date")
+DESTINATION: Final[istr] = istr("Destination")
+DIGEST: Final[istr] = istr("Digest")
+ETAG: Final[istr] = istr("Etag")
+EXPECT: Final[istr] = istr("Expect")
+EXPIRES: Final[istr] = istr("Expires")
+FORWARDED: Final[istr] = istr("Forwarded")
+FROM: Final[istr] = istr("From")
+HOST: Final[istr] = istr("Host")
+IF_MATCH: Final[istr] = istr("If-Match")
+IF_MODIFIED_SINCE: Final[istr] = istr("If-Modified-Since")
+IF_NONE_MATCH: Final[istr] = istr("If-None-Match")
+IF_RANGE: Final[istr] = istr("If-Range")
+IF_UNMODIFIED_SINCE: Final[istr] = istr("If-Unmodified-Since")
+KEEP_ALIVE: Final[istr] = istr("Keep-Alive")
+LAST_EVENT_ID: Final[istr] = istr("Last-Event-ID")
+LAST_MODIFIED: Final[istr] = istr("Last-Modified")
+LINK: Final[istr] = istr("Link")
+LOCATION: Final[istr] = istr("Location")
+MAX_FORWARDS: Final[istr] = istr("Max-Forwards")
+ORIGIN: Final[istr] = istr("Origin")
+PRAGMA: Final[istr] = istr("Pragma")
+PROXY_AUTHENTICATE: Final[istr] = istr("Proxy-Authenticate")
+PROXY_AUTHORIZATION: Final[istr] = istr("Proxy-Authorization")
+RANGE: Final[istr] = istr("Range")
+REFERER: Final[istr] = istr("Referer")
+RETRY_AFTER: Final[istr] = istr("Retry-After")
+SEC_WEBSOCKET_ACCEPT: Final[istr] = istr("Sec-WebSocket-Accept")
+SEC_WEBSOCKET_VERSION: Final[istr] = istr("Sec-WebSocket-Version")
+SEC_WEBSOCKET_PROTOCOL: Final[istr] = istr("Sec-WebSocket-Protocol")
+SEC_WEBSOCKET_EXTENSIONS: Final[istr] = istr("Sec-WebSocket-Extensions")
+SEC_WEBSOCKET_KEY: Final[istr] = istr("Sec-WebSocket-Key")
+SEC_WEBSOCKET_KEY1: Final[istr] = istr("Sec-WebSocket-Key1")
+SERVER: Final[istr] = istr("Server")
+SET_COOKIE: Final[istr] = istr("Set-Cookie")
+TE: Final[istr] = istr("TE")
+TRAILER: Final[istr] = istr("Trailer")
+TRANSFER_ENCODING: Final[istr] = istr("Transfer-Encoding")
+UPGRADE: Final[istr] = istr("Upgrade")
+URI: Final[istr] = istr("URI")
+USER_AGENT: Final[istr] = istr("User-Agent")
+VARY: Final[istr] = istr("Vary")
+VIA: Final[istr] = istr("Via")
+WANT_DIGEST: Final[istr] = istr("Want-Digest")
+WARNING: Final[istr] = istr("Warning")
+WWW_AUTHENTICATE: Final[istr] = istr("WWW-Authenticate")
+X_FORWARDED_FOR: Final[istr] = istr("X-Forwarded-For")
+X_FORWARDED_HOST: Final[istr] = istr("X-Forwarded-Host")
+X_FORWARDED_PROTO: Final[istr] = istr("X-Forwarded-Proto")

env-llmeval/lib/python3.10/site-packages/aiohttp/helpers.py

@@ -0,0 +1,1029 @@
+"""Various helper functions"""
+
+import asyncio
+import base64
+import binascii
+import contextlib
+import datetime
+import enum
+import functools
+import inspect
+import netrc
+import os
+import platform
+import re
+import sys
+import time
+import warnings
+import weakref
+from collections import namedtuple
+from contextlib import suppress
+from email.parser import HeaderParser
+from email.utils import parsedate
+from math import ceil
+from pathlib import Path
+from types import TracebackType
+from typing import (
+    Any,
+    Callable,
+    ContextManager,
+    Dict,
+    Generator,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Pattern,
+    Protocol,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    get_args,
+    overload,
+)
+from urllib.parse import quote
+from urllib.request import getproxies, proxy_bypass
+
+import attr
+from multidict import MultiDict, MultiDictProxy, MultiMapping
+from yarl import URL
+
+from . import hdrs
+from .log import client_logger, internal_logger
+
+if sys.version_info >= (3, 11):
+    import asyncio as async_timeout
+else:
+    import async_timeout
+
+__all__ = ("BasicAuth", "ChainMapProxy", "ETag")
+
+IS_MACOS = platform.system() == "Darwin"
+IS_WINDOWS = platform.system() == "Windows"
+
+PY_310 = sys.version_info >= (3, 10)
+PY_311 = sys.version_info >= (3, 11)
+
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+_SENTINEL = enum.Enum("_SENTINEL", "sentinel")
+sentinel = _SENTINEL.sentinel
+
+NO_EXTENSIONS = bool(os.environ.get("AIOHTTP_NO_EXTENSIONS"))
+
+DEBUG = sys.flags.dev_mode or (
+    not sys.flags.ignore_environment and bool(os.environ.get("PYTHONASYNCIODEBUG"))
+)
+
+
+CHAR = {chr(i) for i in range(0, 128)}
+CTL = {chr(i) for i in range(0, 32)} | {
+    chr(127),
+}
+SEPARATORS = {
+    "(",
+    ")",
+    "<",
+    ">",
+    "@",
+    ",",
+    ";",
+    ":",
+    "\\",
+    '"',
+    "/",
+    "[",
+    "]",
+    "?",
+    "=",
+    "{",
+    "}",
+    " ",
+    chr(9),
+}
+TOKEN = CHAR ^ CTL ^ SEPARATORS
+
+
+class noop:
+    def __await__(self) -> Generator[None, None, None]:
+        yield
+
+
+class BasicAuth(namedtuple("BasicAuth", ["login", "password", "encoding"])):
+    """Http basic authentication helper."""
+
+    def __new__(
+        cls, login: str, password: str = "", encoding: str = "latin1"
+    ) -> "BasicAuth":
+        if login is None:
+            raise ValueError("None is not allowed as login value")
+
+        if password is None:
+            raise ValueError("None is not allowed as password value")
+
+        if ":" in login:
+            raise ValueError('A ":" is not allowed in login (RFC 1945#section-11.1)')
+
+        return super().__new__(cls, login, password, encoding)
+
+    @classmethod
+    def decode(cls, auth_header: str, encoding: str = "latin1") -> "BasicAuth":
+        """Create a BasicAuth object from an Authorization HTTP header."""
+        try:
+            auth_type, encoded_credentials = auth_header.split(" ", 1)
+        except ValueError:
+            raise ValueError("Could not parse authorization header.")
+
+        if auth_type.lower() != "basic":
+            raise ValueError("Unknown authorization method %s" % auth_type)
+
+        try:
+            decoded = base64.b64decode(
+                encoded_credentials.encode("ascii"), validate=True
+            ).decode(encoding)
+        except binascii.Error:
+            raise ValueError("Invalid base64 encoding.")
+
+        try:
+            # RFC 2617 HTTP Authentication
+            # https://www.ietf.org/rfc/rfc2617.txt
+            # the colon must be present, but the username and password may be
+            # otherwise blank.
+            username, password = decoded.split(":", 1)
+        except ValueError:
+            raise ValueError("Invalid credentials.")
+
+        return cls(username, password, encoding=encoding)
+
+    @classmethod
+    def from_url(cls, url: URL, *, encoding: str = "latin1") -> Optional["BasicAuth"]:
+        """Create BasicAuth from url."""
+        if not isinstance(url, URL):
+            raise TypeError("url should be yarl.URL instance")
+        if url.user is None:
+            return None
+        return cls(url.user, url.password or "", encoding=encoding)
+
+    def encode(self) -> str:
+        """Encode credentials."""
+        creds = (f"{self.login}:{self.password}").encode(self.encoding)
+        return "Basic %s" % base64.b64encode(creds).decode(self.encoding)
+
+
+def strip_auth_from_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]:
+    auth = BasicAuth.from_url(url)
+    if auth is None:
+        return url, None
+    else:
+        return url.with_user(None), auth
+
+
+def netrc_from_env() -> Optional[netrc.netrc]:
+    """Load netrc from file.
+
+    Attempt to load it from the path specified by the env-var
+    NETRC or in the default location in the user's home directory.
+
+    Returns None if it couldn't be found or fails to parse.
+    """
+    netrc_env = os.environ.get("NETRC")
+
+    if netrc_env is not None:
+        netrc_path = Path(netrc_env)
+    else:
+        try:
+            home_dir = Path.home()
+        except RuntimeError as e:  # pragma: no cover
+            # if pathlib can't resolve home, it may raise a RuntimeError
+            client_logger.debug(
+                "Could not resolve home directory when "
+                "trying to look for .netrc file: %s",
+                e,
+            )
+            return None
+
+        netrc_path = home_dir / ("_netrc" if IS_WINDOWS else ".netrc")
+
+    try:
+        return netrc.netrc(str(netrc_path))
+    except netrc.NetrcParseError as e:
+        client_logger.warning("Could not parse .netrc file: %s", e)
+    except OSError as e:
+        netrc_exists = False
+        with contextlib.suppress(OSError):
+            netrc_exists = netrc_path.is_file()
+        # we couldn't read the file (doesn't exist, permissions, etc.)
+        if netrc_env or netrc_exists:
+            # only warn if the environment wanted us to load it,
+            # or it appears like the default file does actually exist
+            client_logger.warning("Could not read .netrc file: %s", e)
+
+    return None
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class ProxyInfo:
+    proxy: URL
+    proxy_auth: Optional[BasicAuth]
+
+
+def basicauth_from_netrc(netrc_obj: Optional[netrc.netrc], host: str) -> BasicAuth:
+    """
+    Return :py:class:`~aiohttp.BasicAuth` credentials for ``host`` from ``netrc_obj``.
+
+    :raises LookupError: if ``netrc_obj`` is :py:data:`None` or if no
+            entry is found for the ``host``.
+    """
+    if netrc_obj is None:
+        raise LookupError("No .netrc file found")
+    auth_from_netrc = netrc_obj.authenticators(host)
+
+    if auth_from_netrc is None:
+        raise LookupError(f"No entry for {host!s} found in the `.netrc` file.")
+    login, account, password = auth_from_netrc
+
+    # TODO(PY311): username = login or account
+    # Up to python 3.10, account could be None if not specified,
+    # and login will be empty string if not specified. From 3.11,
+    # login and account will be empty string if not specified.
+    username = login if (login or account is None) else account
+
+    # TODO(PY311): Remove this, as password will be empty string
+    # if not specified
+    if password is None:
+        password = ""
+
+    return BasicAuth(username, password)
+
+
+def proxies_from_env() -> Dict[str, ProxyInfo]:
+    proxy_urls = {
+        k: URL(v)
+        for k, v in getproxies().items()
+        if k in ("http", "https", "ws", "wss")
+    }
+    netrc_obj = netrc_from_env()
+    stripped = {k: strip_auth_from_url(v) for k, v in proxy_urls.items()}
+    ret = {}
+    for proto, val in stripped.items():
+        proxy, auth = val
+        if proxy.scheme in ("https", "wss"):
+            client_logger.warning(
+                "%s proxies %s are not supported, ignoring", proxy.scheme.upper(), proxy
+            )
+            continue
+        if netrc_obj and auth is None:
+            if proxy.host is not None:
+                try:
+                    auth = basicauth_from_netrc(netrc_obj, proxy.host)
+                except LookupError:
+                    auth = None
+        ret[proto] = ProxyInfo(proxy, auth)
+    return ret
+
+
+def current_task(
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> "Optional[asyncio.Task[Any]]":
+    return asyncio.current_task(loop=loop)
+
+
+def get_running_loop(
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> asyncio.AbstractEventLoop:
+    if loop is None:
+        loop = asyncio.get_event_loop()
+    if not loop.is_running():
+        warnings.warn(
+            "The object should be created within an async function",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+        if loop.get_debug():
+            internal_logger.warning(
+                "The object should be created within an async function", stack_info=True
+            )
+    return loop
+
+
+def isasyncgenfunction(obj: Any) -> bool:
+    func = getattr(inspect, "isasyncgenfunction", None)
+    if func is not None:
+        return func(obj)  # type: ignore[no-any-return]
+    else:
+        return False
+
+
+def get_env_proxy_for_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]:
+    """Get a permitted proxy for the given URL from the env."""
+    if url.host is not None and proxy_bypass(url.host):
+        raise LookupError(f"Proxying is disallowed for `{url.host!r}`")
+
+    proxies_in_env = proxies_from_env()
+    try:
+        proxy_info = proxies_in_env[url.scheme]
+    except KeyError:
+        raise LookupError(f"No proxies found for `{url!s}` in the env")
+    else:
+        return proxy_info.proxy, proxy_info.proxy_auth
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class MimeType:
+    type: str
+    subtype: str
+    suffix: str
+    parameters: "MultiDictProxy[str]"
+
+
+@functools.lru_cache(maxsize=56)
+def parse_mimetype(mimetype: str) -> MimeType:
+    """Parses a MIME type into its components.
+
+    mimetype is a MIME type string.
+
+    Returns a MimeType object.
+
+    Example:
+
+    >>> parse_mimetype('text/html; charset=utf-8')
+    MimeType(type='text', subtype='html', suffix='',
+             parameters={'charset': 'utf-8'})
+
+    """
+    if not mimetype:
+        return MimeType(
+            type="", subtype="", suffix="", parameters=MultiDictProxy(MultiDict())
+        )
+
+    parts = mimetype.split(";")
+    params: MultiDict[str] = MultiDict()
+    for item in parts[1:]:
+        if not item:
+            continue
+        key, _, value = item.partition("=")
+        params.add(key.lower().strip(), value.strip(' "'))
+
+    fulltype = parts[0].strip().lower()
+    if fulltype == "*":
+        fulltype = "*/*"
+
+    mtype, _, stype = fulltype.partition("/")
+    stype, _, suffix = stype.partition("+")
+
+    return MimeType(
+        type=mtype, subtype=stype, suffix=suffix, parameters=MultiDictProxy(params)
+    )
+
+
+def guess_filename(obj: Any, default: Optional[str] = None) -> Optional[str]:
+    name = getattr(obj, "name", None)
+    if name and isinstance(name, str) and name[0] != "<" and name[-1] != ">":
+        return Path(name).name
+    return default
+
+
+not_qtext_re = re.compile(r"[^\041\043-\133\135-\176]")
+QCONTENT = {chr(i) for i in range(0x20, 0x7F)} | {"\t"}
+
+
+def quoted_string(content: str) -> str:
+    """Return 7-bit content as quoted-string.
+
+    Format content into a quoted-string as defined in RFC5322 for
+    Internet Message Format. Notice that this is not the 8-bit HTTP
+    format, but the 7-bit email format. Content must be in usascii or
+    a ValueError is raised.
+    """
+    if not (QCONTENT > set(content)):
+        raise ValueError(f"bad content for quoted-string {content!r}")
+    return not_qtext_re.sub(lambda x: "\\" + x.group(0), content)
+
+
+def content_disposition_header(
+    disptype: str, quote_fields: bool = True, _charset: str = "utf-8", **params: str
+) -> str:
+    """Sets ``Content-Disposition`` header for MIME.
+
+    This is the MIME payload Content-Disposition header from RFC 2183
+    and RFC 7579 section 4.2, not the HTTP Content-Disposition from
+    RFC 6266.
+
+    disptype is a disposition type: inline, attachment, form-data.
+    Should be valid extension token (see RFC 2183)
+
+    quote_fields performs value quoting to 7-bit MIME headers
+    according to RFC 7578. Set to quote_fields to False if recipient
+    can take 8-bit file names and field values.
+
+    _charset specifies the charset to use when quote_fields is True.
+
+    params is a dict with disposition params.
+    """
+    if not disptype or not (TOKEN > set(disptype)):
+        raise ValueError("bad content disposition type {!r}" "".format(disptype))
+
+    value = disptype
+    if params:
+        lparams = []
+        for key, val in params.items():
+            if not key or not (TOKEN > set(key)):
+                raise ValueError(
+                    "bad content disposition parameter" " {!r}={!r}".format(key, val)
+                )
+            if quote_fields:
+                if key.lower() == "filename":
+                    qval = quote(val, "", encoding=_charset)
+                    lparams.append((key, '"%s"' % qval))
+                else:
+                    try:
+                        qval = quoted_string(val)
+                    except ValueError:
+                        qval = "".join(
+                            (_charset, "''", quote(val, "", encoding=_charset))
+                        )
+                        lparams.append((key + "*", qval))
+                    else:
+                        lparams.append((key, '"%s"' % qval))
+            else:
+                qval = val.replace("\\", "\\\\").replace('"', '\\"')
+                lparams.append((key, '"%s"' % qval))
+        sparams = "; ".join("=".join(pair) for pair in lparams)
+        value = "; ".join((value, sparams))
+    return value
+
+
+class _TSelf(Protocol, Generic[_T]):
+    _cache: Dict[str, _T]
+
+
+class reify(Generic[_T]):
+    """Use as a class method decorator.
+
+    It operates almost exactly like
+    the Python `@property` decorator, but it puts the result of the
+    method it decorates into the instance dict after the first call,
+    effectively replacing the function it decorates with an instance
+    variable.  It is, in Python parlance, a data descriptor.
+    """
+
+    def __init__(self, wrapped: Callable[..., _T]) -> None:
+        self.wrapped = wrapped
+        self.__doc__ = wrapped.__doc__
+        self.name = wrapped.__name__
+
+    def __get__(self, inst: _TSelf[_T], owner: Optional[Type[Any]] = None) -> _T:
+        try:
+            try:
+                return inst._cache[self.name]
+            except KeyError:
+                val = self.wrapped(inst)
+                inst._cache[self.name] = val
+                return val
+        except AttributeError:
+            if inst is None:
+                return self
+            raise
+
+    def __set__(self, inst: _TSelf[_T], value: _T) -> None:
+        raise AttributeError("reified property is read-only")
+
+
+reify_py = reify
+
+try:
+    from ._helpers import reify as reify_c
+
+    if not NO_EXTENSIONS:
+        reify = reify_c  # type: ignore[misc,assignment]
+except ImportError:
+    pass
+
+_ipv4_pattern = (
+    r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"
+    r"(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
+)
+_ipv6_pattern = (
+    r"^(?:(?:(?:[A-F0-9]{1,4}:){6}|(?=(?:[A-F0-9]{0,4}:){0,6}"
+    r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}$)(([0-9A-F]{1,4}:){0,5}|:)"
+    r"((:[0-9A-F]{1,4}){1,5}:|:)|::(?:[A-F0-9]{1,4}:){5})"
+    r"(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}"
+    r"(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|(?:[A-F0-9]{1,4}:){7}"
+    r"[A-F0-9]{1,4}|(?=(?:[A-F0-9]{0,4}:){0,7}[A-F0-9]{0,4}$)"
+    r"(([0-9A-F]{1,4}:){1,7}|:)((:[0-9A-F]{1,4}){1,7}|:)|(?:[A-F0-9]{1,4}:){7}"
+    r":|:(:[A-F0-9]{1,4}){7})$"
+)
+_ipv4_regex = re.compile(_ipv4_pattern)
+_ipv6_regex = re.compile(_ipv6_pattern, flags=re.IGNORECASE)
+_ipv4_regexb = re.compile(_ipv4_pattern.encode("ascii"))
+_ipv6_regexb = re.compile(_ipv6_pattern.encode("ascii"), flags=re.IGNORECASE)
+
+
+def _is_ip_address(
+    regex: Pattern[str], regexb: Pattern[bytes], host: Optional[Union[str, bytes]]
+) -> bool:
+    if host is None:
+        return False
+    if isinstance(host, str):
+        return bool(regex.match(host))
+    elif isinstance(host, (bytes, bytearray, memoryview)):
+        return bool(regexb.match(host))
+    else:
+        raise TypeError(f"{host} [{type(host)}] is not a str or bytes")
+
+
+is_ipv4_address = functools.partial(_is_ip_address, _ipv4_regex, _ipv4_regexb)
+is_ipv6_address = functools.partial(_is_ip_address, _ipv6_regex, _ipv6_regexb)
+
+
+def is_ip_address(host: Optional[Union[str, bytes, bytearray, memoryview]]) -> bool:
+    return is_ipv4_address(host) or is_ipv6_address(host)
+
+
+_cached_current_datetime: Optional[int] = None
+_cached_formatted_datetime = ""
+
+
+def rfc822_formatted_time() -> str:
+    global _cached_current_datetime
+    global _cached_formatted_datetime
+
+    now = int(time.time())
+    if now != _cached_current_datetime:
+        # Weekday and month names for HTTP date/time formatting;
+        # always English!
+        # Tuples are constants stored in codeobject!
+        _weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
+        _monthname = (
+            "",  # Dummy so we can use 1-based month numbers
+            "Jan",
+            "Feb",
+            "Mar",
+            "Apr",
+            "May",
+            "Jun",
+            "Jul",
+            "Aug",
+            "Sep",
+            "Oct",
+            "Nov",
+            "Dec",
+        )
+
+        year, month, day, hh, mm, ss, wd, *tail = time.gmtime(now)
+        _cached_formatted_datetime = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
+            _weekdayname[wd],
+            day,
+            _monthname[month],
+            year,
+            hh,
+            mm,
+            ss,
+        )
+        _cached_current_datetime = now
+    return _cached_formatted_datetime
+
+
+def _weakref_handle(info: "Tuple[weakref.ref[object], str]") -> None:
+    ref, name = info
+    ob = ref()
+    if ob is not None:
+        with suppress(Exception):
+            getattr(ob, name)()
+
+
+def weakref_handle(
+    ob: object,
+    name: str,
+    timeout: float,
+    loop: asyncio.AbstractEventLoop,
+    timeout_ceil_threshold: float = 5,
+) -> Optional[asyncio.TimerHandle]:
+    if timeout is not None and timeout > 0:
+        when = loop.time() + timeout
+        if timeout >= timeout_ceil_threshold:
+            when = ceil(when)
+
+        return loop.call_at(when, _weakref_handle, (weakref.ref(ob), name))
+    return None
+
+
+def call_later(
+    cb: Callable[[], Any],
+    timeout: float,
+    loop: asyncio.AbstractEventLoop,
+    timeout_ceil_threshold: float = 5,
+) -> Optional[asyncio.TimerHandle]:
+    if timeout is not None and timeout > 0:
+        when = loop.time() + timeout
+        if timeout > timeout_ceil_threshold:
+            when = ceil(when)
+        return loop.call_at(when, cb)
+    return None
+
+
+class TimeoutHandle:
+    """Timeout handle"""
+
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop,
+        timeout: Optional[float],
+        ceil_threshold: float = 5,
+    ) -> None:
+        self._timeout = timeout
+        self._loop = loop
+        self._ceil_threshold = ceil_threshold
+        self._callbacks: List[
+            Tuple[Callable[..., None], Tuple[Any, ...], Dict[str, Any]]
+        ] = []
+
+    def register(
+        self, callback: Callable[..., None], *args: Any, **kwargs: Any
+    ) -> None:
+        self._callbacks.append((callback, args, kwargs))
+
+    def close(self) -> None:
+        self._callbacks.clear()
+
+    def start(self) -> Optional[asyncio.Handle]:
+        timeout = self._timeout
+        if timeout is not None and timeout > 0:
+            when = self._loop.time() + timeout
+            if timeout >= self._ceil_threshold:
+                when = ceil(when)
+            return self._loop.call_at(when, self.__call__)
+        else:
+            return None
+
+    def timer(self) -> "BaseTimerContext":
+        if self._timeout is not None and self._timeout > 0:
+            timer = TimerContext(self._loop)
+            self.register(timer.timeout)
+            return timer
+        else:
+            return TimerNoop()
+
+    def __call__(self) -> None:
+        for cb, args, kwargs in self._callbacks:
+            with suppress(Exception):
+                cb(*args, **kwargs)
+
+        self._callbacks.clear()
+
+
+class BaseTimerContext(ContextManager["BaseTimerContext"]):
+    def assert_timeout(self) -> None:
+        """Raise TimeoutError if timeout has been exceeded."""
+
+
+class TimerNoop(BaseTimerContext):
+    def __enter__(self) -> BaseTimerContext:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        return
+
+
+class TimerContext(BaseTimerContext):
+    """Low resolution timeout context manager"""
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._tasks: List[asyncio.Task[Any]] = []
+        self._cancelled = False
+
+    def assert_timeout(self) -> None:
+        """Raise TimeoutError if timer has already been cancelled."""
+        if self._cancelled:
+            raise asyncio.TimeoutError from None
+
+    def __enter__(self) -> BaseTimerContext:
+        task = current_task(loop=self._loop)
+
+        if task is None:
+            raise RuntimeError(
+                "Timeout context manager should be used " "inside a task"
+            )
+
+        if self._cancelled:
+            raise asyncio.TimeoutError from None
+
+        self._tasks.append(task)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        if self._tasks:
+            self._tasks.pop()
+
+        if exc_type is asyncio.CancelledError and self._cancelled:
+            raise asyncio.TimeoutError from None
+        return None
+
+    def timeout(self) -> None:
+        if not self._cancelled:
+            for task in set(self._tasks):
+                task.cancel()
+
+            self._cancelled = True
+
+
+def ceil_timeout(
+    delay: Optional[float], ceil_threshold: float = 5
+) -> async_timeout.Timeout:
+    if delay is None or delay <= 0:
+        return async_timeout.timeout(None)
+
+    loop = get_running_loop()
+    now = loop.time()
+    when = now + delay
+    if delay > ceil_threshold:
+        when = ceil(when)
+    return async_timeout.timeout_at(when)
+
+
+class HeadersMixin:
+    ATTRS = frozenset(["_content_type", "_content_dict", "_stored_content_type"])
+
+    _headers: MultiMapping[str]
+
+    _content_type: Optional[str] = None
+    _content_dict: Optional[Dict[str, str]] = None
+    _stored_content_type: Union[str, None, _SENTINEL] = sentinel
+
+    def _parse_content_type(self, raw: Optional[str]) -> None:
+        self._stored_content_type = raw
+        if raw is None:
+            # default value according to RFC 2616
+            self._content_type = "application/octet-stream"
+            self._content_dict = {}
+        else:
+            msg = HeaderParser().parsestr("Content-Type: " + raw)
+            self._content_type = msg.get_content_type()
+            params = msg.get_params(())
+            self._content_dict = dict(params[1:])  # First element is content type again
+
+    @property
+    def content_type(self) -> str:
+        """The value of content part for Content-Type HTTP header."""
+        raw = self._headers.get(hdrs.CONTENT_TYPE)
+        if self._stored_content_type != raw:
+            self._parse_content_type(raw)
+        return self._content_type  # type: ignore[return-value]
+
+    @property
+    def charset(self) -> Optional[str]:
+        """The value of charset part for Content-Type HTTP header."""
+        raw = self._headers.get(hdrs.CONTENT_TYPE)
+        if self._stored_content_type != raw:
+            self._parse_content_type(raw)
+        return self._content_dict.get("charset")  # type: ignore[union-attr]
+
+    @property
+    def content_length(self) -> Optional[int]:
+        """The value of Content-Length HTTP header."""
+        content_length = self._headers.get(hdrs.CONTENT_LENGTH)
+
+        if content_length is not None:
+            return int(content_length)
+        else:
+            return None
+
+
+def set_result(fut: "asyncio.Future[_T]", result: _T) -> None:
+    if not fut.done():
+        fut.set_result(result)
+
+
+_EXC_SENTINEL = BaseException()
+
+
+class ErrorableProtocol(Protocol):
+    def set_exception(
+        self,
+        exc: BaseException,
+        exc_cause: BaseException = ...,
+    ) -> None:
+        ...  # pragma: no cover
+
+
+def set_exception(
+    fut: "asyncio.Future[_T] | ErrorableProtocol",
+    exc: BaseException,
+    exc_cause: BaseException = _EXC_SENTINEL,
+) -> None:
+    """Set future exception.
+
+    If the future is marked as complete, this function is a no-op.
+
+    :param exc_cause: An exception that is a direct cause of ``exc``.
+                      Only set if provided.
+    """
+    if asyncio.isfuture(fut) and fut.done():
+        return
+
+    exc_is_sentinel = exc_cause is _EXC_SENTINEL
+    exc_causes_itself = exc is exc_cause
+    if not exc_is_sentinel and not exc_causes_itself:
+        exc.__cause__ = exc_cause
+
+    fut.set_exception(exc)
+
+
+@functools.total_ordering
+class AppKey(Generic[_T]):
+    """Keys for static typing support in Application."""
+
+    __slots__ = ("_name", "_t", "__orig_class__")
+
+    # This may be set by Python when instantiating with a generic type. We need to
+    # support this, in order to support types that are not concrete classes,
+    # like Iterable, which can't be passed as the second parameter to __init__.
+    __orig_class__: Type[object]
+
+    def __init__(self, name: str, t: Optional[Type[_T]] = None):
+        # Prefix with module name to help deduplicate key names.
+        frame = inspect.currentframe()
+        while frame:
+            if frame.f_code.co_name == "<module>":
+                module: str = frame.f_globals["__name__"]
+                break
+            frame = frame.f_back
+
+        self._name = module + "." + name
+        self._t = t
+
+    def __lt__(self, other: object) -> bool:
+        if isinstance(other, AppKey):
+            return self._name < other._name
+        return True  # Order AppKey above other types.
+
+    def __repr__(self) -> str:
+        t = self._t
+        if t is None:
+            with suppress(AttributeError):
+                # Set to type arg.
+                t = get_args(self.__orig_class__)[0]
+
+        if t is None:
+            t_repr = "<<Unknown>>"
+        elif isinstance(t, type):
+            if t.__module__ == "builtins":
+                t_repr = t.__qualname__
+            else:
+                t_repr = f"{t.__module__}.{t.__qualname__}"
+        else:
+            t_repr = repr(t)
+        return f"<AppKey({self._name}, type={t_repr})>"
+
+
+class ChainMapProxy(Mapping[Union[str, AppKey[Any]], Any]):
+    __slots__ = ("_maps",)
+
+    def __init__(self, maps: Iterable[Mapping[Union[str, AppKey[Any]], Any]]) -> None:
+        self._maps = tuple(maps)
+
+    def __init_subclass__(cls) -> None:
+        raise TypeError(
+            "Inheritance class {} from ChainMapProxy "
+            "is forbidden".format(cls.__name__)
+        )
+
+    @overload  # type: ignore[override]
+    def __getitem__(self, key: AppKey[_T]) -> _T:
+        ...
+
+    @overload
+    def __getitem__(self, key: str) -> Any:
+        ...
+
+    def __getitem__(self, key: Union[str, AppKey[_T]]) -> Any:
+        for mapping in self._maps:
+            try:
+                return mapping[key]
+            except KeyError:
+                pass
+        raise KeyError(key)
+
+    @overload  # type: ignore[override]
+    def get(self, key: AppKey[_T], default: _S) -> Union[_T, _S]:
+        ...
+
+    @overload
+    def get(self, key: AppKey[_T], default: None = ...) -> Optional[_T]:
+        ...
+
+    @overload
+    def get(self, key: str, default: Any = ...) -> Any:
+        ...
+
+    def get(self, key: Union[str, AppKey[_T]], default: Any = None) -> Any:
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def __len__(self) -> int:
+        # reuses stored hash values if possible
+        return len(set().union(*self._maps))
+
+    def __iter__(self) -> Iterator[Union[str, AppKey[Any]]]:
+        d: Dict[Union[str, AppKey[Any]], Any] = {}
+        for mapping in reversed(self._maps):
+            # reuses stored hash values if possible
+            d.update(mapping)
+        return iter(d)
+
+    def __contains__(self, key: object) -> bool:
+        return any(key in m for m in self._maps)
+
+    def __bool__(self) -> bool:
+        return any(self._maps)
+
+    def __repr__(self) -> str:
+        content = ", ".join(map(repr, self._maps))
+        return f"ChainMapProxy({content})"
+
+
+# https://tools.ietf.org/html/rfc7232#section-2.3
+_ETAGC = r"[!\x23-\x7E\x80-\xff]+"
+_ETAGC_RE = re.compile(_ETAGC)
+_QUOTED_ETAG = rf'(W/)?"({_ETAGC})"'
+QUOTED_ETAG_RE = re.compile(_QUOTED_ETAG)
+LIST_QUOTED_ETAG_RE = re.compile(rf"({_QUOTED_ETAG})(?:\s*,\s*|$)|(.)")
+
+ETAG_ANY = "*"
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class ETag:
+    value: str
+    is_weak: bool = False
+
+
+def validate_etag_value(value: str) -> None:
+    if value != ETAG_ANY and not _ETAGC_RE.fullmatch(value):
+        raise ValueError(
+            f"Value {value!r} is not a valid etag. Maybe it contains '\"'?"
+        )
+
+
+def parse_http_date(date_str: Optional[str]) -> Optional[datetime.datetime]:
+    """Process a date string, return a datetime object"""
+    if date_str is not None:
+        timetuple = parsedate(date_str)
+        if timetuple is not None:
+            with suppress(ValueError):
+                return datetime.datetime(*timetuple[:6], tzinfo=datetime.timezone.utc)
+    return None
+
+
+def must_be_empty_body(method: str, code: int) -> bool:
+    """Check if a request must return an empty body."""
+    return (
+        status_code_must_be_empty_body(code)
+        or method_must_be_empty_body(method)
+        or (200 <= code < 300 and method.upper() == hdrs.METH_CONNECT)
+    )
+
+
+def method_must_be_empty_body(method: str) -> bool:
+    """Check if a method must return an empty body."""
+    # https://datatracker.ietf.org/doc/html/rfc9112#section-6.3-2.1
+    # https://datatracker.ietf.org/doc/html/rfc9112#section-6.3-2.2
+    return method.upper() == hdrs.METH_HEAD
+
+
+def status_code_must_be_empty_body(code: int) -> bool:
+    """Check if a status code must return an empty body."""
+    # https://datatracker.ietf.org/doc/html/rfc9112#section-6.3-2.1
+    return code in {204, 304} or 100 <= code < 200
+
+
+def should_remove_content_length(method: str, code: int) -> bool:
+    """Check if a Content-Length header should be removed.
+
+    This should always be a subset of must_be_empty_body
+    """
+    # https://www.rfc-editor.org/rfc/rfc9110.html#section-8.6-8
+    # https://www.rfc-editor.org/rfc/rfc9110.html#section-15.4.5-4
+    return (
+        code in {204, 304}
+        or 100 <= code < 200
+        or (200 <= code < 300 and method.upper() == hdrs.METH_CONNECT)
+    )

env-llmeval/lib/python3.10/site-packages/aiohttp/http.py

@@ -0,0 +1,72 @@
+import sys
+from http import HTTPStatus
+from typing import Mapping, Tuple
+
+from . import __version__
+from .http_exceptions import HttpProcessingError as HttpProcessingError
+from .http_parser import (
+    HeadersParser as HeadersParser,
+    HttpParser as HttpParser,
+    HttpRequestParser as HttpRequestParser,
+    HttpResponseParser as HttpResponseParser,
+    RawRequestMessage as RawRequestMessage,
+    RawResponseMessage as RawResponseMessage,
+)
+from .http_websocket import (
+    WS_CLOSED_MESSAGE as WS_CLOSED_MESSAGE,
+    WS_CLOSING_MESSAGE as WS_CLOSING_MESSAGE,
+    WS_KEY as WS_KEY,
+    WebSocketError as WebSocketError,
+    WebSocketReader as WebSocketReader,
+    WebSocketWriter as WebSocketWriter,
+    WSCloseCode as WSCloseCode,
+    WSMessage as WSMessage,
+    WSMsgType as WSMsgType,
+    ws_ext_gen as ws_ext_gen,
+    ws_ext_parse as ws_ext_parse,
+)
+from .http_writer import (
+    HttpVersion as HttpVersion,
+    HttpVersion10 as HttpVersion10,
+    HttpVersion11 as HttpVersion11,
+    StreamWriter as StreamWriter,
+)
+
+__all__ = (
+    "HttpProcessingError",
+    "RESPONSES",
+    "SERVER_SOFTWARE",
+    # .http_writer
+    "StreamWriter",
+    "HttpVersion",
+    "HttpVersion10",
+    "HttpVersion11",
+    # .http_parser
+    "HeadersParser",
+    "HttpParser",
+    "HttpRequestParser",
+    "HttpResponseParser",
+    "RawRequestMessage",
+    "RawResponseMessage",
+    # .http_websocket
+    "WS_CLOSED_MESSAGE",
+    "WS_CLOSING_MESSAGE",
+    "WS_KEY",
+    "WebSocketReader",
+    "WebSocketWriter",
+    "ws_ext_gen",
+    "ws_ext_parse",
+    "WSMessage",
+    "WebSocketError",
+    "WSMsgType",
+    "WSCloseCode",
+)
+
+
+SERVER_SOFTWARE: str = "Python/{0[0]}.{0[1]} aiohttp/{1}".format(
+    sys.version_info, __version__
+)
+
+RESPONSES: Mapping[int, Tuple[str, str]] = {
+    v: (v.phrase, v.description) for v in HTTPStatus.__members__.values()
+}

env-llmeval/lib/python3.10/site-packages/aiohttp/http_exceptions.py

@@ -0,0 +1,106 @@
+"""Low-level http related exceptions."""
+
+
+from textwrap import indent
+from typing import Optional, Union
+
+from .typedefs import _CIMultiDict
+
+__all__ = ("HttpProcessingError",)
+
+
+class HttpProcessingError(Exception):
+    """HTTP error.
+
+    Shortcut for raising HTTP errors with custom code, message and headers.
+
+    code: HTTP Error code.
+    message: (optional) Error message.
+    headers: (optional) Headers to be sent in response, a list of pairs
+    """
+
+    code = 0
+    message = ""
+    headers = None
+
+    def __init__(
+        self,
+        *,
+        code: Optional[int] = None,
+        message: str = "",
+        headers: Optional[_CIMultiDict] = None,
+    ) -> None:
+        if code is not None:
+            self.code = code
+        self.headers = headers
+        self.message = message
+
+    def __str__(self) -> str:
+        msg = indent(self.message, "  ")
+        return f"{self.code}, message:\n{msg}"
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: {self.code}, message={self.message!r}>"
+
+
+class BadHttpMessage(HttpProcessingError):
+
+    code = 400
+    message = "Bad Request"
+
+    def __init__(self, message: str, *, headers: Optional[_CIMultiDict] = None) -> None:
+        super().__init__(message=message, headers=headers)
+        self.args = (message,)
+
+
+class HttpBadRequest(BadHttpMessage):
+
+    code = 400
+    message = "Bad Request"
+
+
+class PayloadEncodingError(BadHttpMessage):
+    """Base class for payload errors"""
+
+
+class ContentEncodingError(PayloadEncodingError):
+    """Content encoding error."""
+
+
+class TransferEncodingError(PayloadEncodingError):
+    """transfer encoding error."""
+
+
+class ContentLengthError(PayloadEncodingError):
+    """Not enough data for satisfy content length header."""
+
+
+class LineTooLong(BadHttpMessage):
+    def __init__(
+        self, line: str, limit: str = "Unknown", actual_size: str = "Unknown"
+    ) -> None:
+        super().__init__(
+            f"Got more than {limit} bytes ({actual_size}) when reading {line}."
+        )
+        self.args = (line, limit, actual_size)
+
+
+class InvalidHeader(BadHttpMessage):
+    def __init__(self, hdr: Union[bytes, str]) -> None:
+        hdr_s = hdr.decode(errors="backslashreplace") if isinstance(hdr, bytes) else hdr
+        super().__init__(f"Invalid HTTP header: {hdr!r}")
+        self.hdr = hdr_s
+        self.args = (hdr,)
+
+
+class BadStatusLine(BadHttpMessage):
+    def __init__(self, line: str = "", error: Optional[str] = None) -> None:
+        if not isinstance(line, str):
+            line = repr(line)
+        super().__init__(error or f"Bad status line {line!r}")
+        self.args = (line,)
+        self.line = line
+
+
+class InvalidURLError(BadHttpMessage):
+    pass

env-llmeval/lib/python3.10/site-packages/aiohttp/http_parser.py

@@ -0,0 +1,1041 @@
+import abc
+import asyncio
+import re
+import string
+from contextlib import suppress
+from enum import IntEnum
+from typing import (
+    Any,
+    ClassVar,
+    Final,
+    Generic,
+    List,
+    Literal,
+    NamedTuple,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from multidict import CIMultiDict, CIMultiDictProxy, istr
+from yarl import URL
+
+from . import hdrs
+from .base_protocol import BaseProtocol
+from .compression_utils import HAS_BROTLI, BrotliDecompressor, ZLibDecompressor
+from .helpers import (
+    _EXC_SENTINEL,
+    DEBUG,
+    NO_EXTENSIONS,
+    BaseTimerContext,
+    method_must_be_empty_body,
+    set_exception,
+    status_code_must_be_empty_body,
+)
+from .http_exceptions import (
+    BadHttpMessage,
+    BadStatusLine,
+    ContentEncodingError,
+    ContentLengthError,
+    InvalidHeader,
+    InvalidURLError,
+    LineTooLong,
+    TransferEncodingError,
+)
+from .http_writer import HttpVersion, HttpVersion10
+from .log import internal_logger
+from .streams import EMPTY_PAYLOAD, StreamReader
+from .typedefs import RawHeaders
+
+__all__ = (
+    "HeadersParser",
+    "HttpParser",
+    "HttpRequestParser",
+    "HttpResponseParser",
+    "RawRequestMessage",
+    "RawResponseMessage",
+)
+
+_SEP = Literal[b"\r\n", b"\n"]
+
+ASCIISET: Final[Set[str]] = set(string.printable)
+
+# See https://www.rfc-editor.org/rfc/rfc9110.html#name-overview
+# and https://www.rfc-editor.org/rfc/rfc9110.html#name-tokens
+#
+#     method = token
+#     tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
+#             "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
+#     token = 1*tchar
+_TCHAR_SPECIALS: Final[str] = re.escape("!#$%&'*+-.^_`|~")
+TOKENRE: Final[Pattern[str]] = re.compile(f"[0-9A-Za-z{_TCHAR_SPECIALS}]+")
+VERSRE: Final[Pattern[str]] = re.compile(r"HTTP/(\d)\.(\d)", re.ASCII)
+DIGITS: Final[Pattern[str]] = re.compile(r"\d+", re.ASCII)
+HEXDIGITS: Final[Pattern[bytes]] = re.compile(rb"[0-9a-fA-F]+")
+
+
+class RawRequestMessage(NamedTuple):
+    method: str
+    path: str
+    version: HttpVersion
+    headers: "CIMultiDictProxy[str]"
+    raw_headers: RawHeaders
+    should_close: bool
+    compression: Optional[str]
+    upgrade: bool
+    chunked: bool
+    url: URL
+
+
+class RawResponseMessage(NamedTuple):
+    version: HttpVersion
+    code: int
+    reason: str
+    headers: CIMultiDictProxy[str]
+    raw_headers: RawHeaders
+    should_close: bool
+    compression: Optional[str]
+    upgrade: bool
+    chunked: bool
+
+
+_MsgT = TypeVar("_MsgT", RawRequestMessage, RawResponseMessage)
+
+
+class ParseState(IntEnum):
+
+    PARSE_NONE = 0
+    PARSE_LENGTH = 1
+    PARSE_CHUNKED = 2
+    PARSE_UNTIL_EOF = 3
+
+
+class ChunkState(IntEnum):
+    PARSE_CHUNKED_SIZE = 0
+    PARSE_CHUNKED_CHUNK = 1
+    PARSE_CHUNKED_CHUNK_EOF = 2
+    PARSE_MAYBE_TRAILERS = 3
+    PARSE_TRAILERS = 4
+
+
+class HeadersParser:
+    def __init__(
+        self,
+        max_line_size: int = 8190,
+        max_headers: int = 32768,
+        max_field_size: int = 8190,
+        lax: bool = False,
+    ) -> None:
+        self.max_line_size = max_line_size
+        self.max_headers = max_headers
+        self.max_field_size = max_field_size
+        self._lax = lax
+
+    def parse_headers(
+        self, lines: List[bytes]
+    ) -> Tuple["CIMultiDictProxy[str]", RawHeaders]:
+        headers: CIMultiDict[str] = CIMultiDict()
+        # note: "raw" does not mean inclusion of OWS before/after the field value
+        raw_headers = []
+
+        lines_idx = 1
+        line = lines[1]
+        line_count = len(lines)
+
+        while line:
+            # Parse initial header name : value pair.
+            try:
+                bname, bvalue = line.split(b":", 1)
+            except ValueError:
+                raise InvalidHeader(line) from None
+
+            if len(bname) == 0:
+                raise InvalidHeader(bname)
+
+            # https://www.rfc-editor.org/rfc/rfc9112.html#section-5.1-2
+            if {bname[0], bname[-1]} & {32, 9}:  # {" ", "\t"}
+                raise InvalidHeader(line)
+
+            bvalue = bvalue.lstrip(b" \t")
+            if len(bname) > self.max_field_size:
+                raise LineTooLong(
+                    "request header name {}".format(
+                        bname.decode("utf8", "backslashreplace")
+                    ),
+                    str(self.max_field_size),
+                    str(len(bname)),
+                )
+            name = bname.decode("utf-8", "surrogateescape")
+            if not TOKENRE.fullmatch(name):
+                raise InvalidHeader(bname)
+
+            header_length = len(bvalue)
+
+            # next line
+            lines_idx += 1
+            line = lines[lines_idx]
+
+            # consume continuation lines
+            continuation = self._lax and line and line[0] in (32, 9)  # (' ', '\t')
+
+            # Deprecated: https://www.rfc-editor.org/rfc/rfc9112.html#name-obsolete-line-folding
+            if continuation:
+                bvalue_lst = [bvalue]
+                while continuation:
+                    header_length += len(line)
+                    if header_length > self.max_field_size:
+                        raise LineTooLong(
+                            "request header field {}".format(
+                                bname.decode("utf8", "backslashreplace")
+                            ),
+                            str(self.max_field_size),
+                            str(header_length),
+                        )
+                    bvalue_lst.append(line)
+
+                    # next line
+                    lines_idx += 1
+                    if lines_idx < line_count:
+                        line = lines[lines_idx]
+                        if line:
+                            continuation = line[0] in (32, 9)  # (' ', '\t')
+                    else:
+                        line = b""
+                        break
+                bvalue = b"".join(bvalue_lst)
+            else:
+                if header_length > self.max_field_size:
+                    raise LineTooLong(
+                        "request header field {}".format(
+                            bname.decode("utf8", "backslashreplace")
+                        ),
+                        str(self.max_field_size),
+                        str(header_length),
+                    )
+
+            bvalue = bvalue.strip(b" \t")
+            value = bvalue.decode("utf-8", "surrogateescape")
+
+            # https://www.rfc-editor.org/rfc/rfc9110.html#section-5.5-5
+            if "\n" in value or "\r" in value or "\x00" in value:
+                raise InvalidHeader(bvalue)
+
+            headers.add(name, value)
+            raw_headers.append((bname, bvalue))
+
+        return (CIMultiDictProxy(headers), tuple(raw_headers))
+
+
+def _is_supported_upgrade(headers: CIMultiDictProxy[str]) -> bool:
+    """Check if the upgrade header is supported."""
+    return headers.get(hdrs.UPGRADE, "").lower() in {"tcp", "websocket"}
+
+
+class HttpParser(abc.ABC, Generic[_MsgT]):
+    lax: ClassVar[bool] = False
+
+    def __init__(
+        self,
+        protocol: Optional[BaseProtocol] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        limit: int = 2**16,
+        max_line_size: int = 8190,
+        max_headers: int = 32768,
+        max_field_size: int = 8190,
+        timer: Optional[BaseTimerContext] = None,
+        code: Optional[int] = None,
+        method: Optional[str] = None,
+        readall: bool = False,
+        payload_exception: Optional[Type[BaseException]] = None,
+        response_with_body: bool = True,
+        read_until_eof: bool = False,
+        auto_decompress: bool = True,
+    ) -> None:
+        self.protocol = protocol
+        self.loop = loop
+        self.max_line_size = max_line_size
+        self.max_headers = max_headers
+        self.max_field_size = max_field_size
+        self.timer = timer
+        self.code = code
+        self.method = method
+        self.readall = readall
+        self.payload_exception = payload_exception
+        self.response_with_body = response_with_body
+        self.read_until_eof = read_until_eof
+
+        self._lines: List[bytes] = []
+        self._tail = b""
+        self._upgraded = False
+        self._payload = None
+        self._payload_parser: Optional[HttpPayloadParser] = None
+        self._auto_decompress = auto_decompress
+        self._limit = limit
+        self._headers_parser = HeadersParser(
+            max_line_size, max_headers, max_field_size, self.lax
+        )
+
+    @abc.abstractmethod
+    def parse_message(self, lines: List[bytes]) -> _MsgT:
+        pass
+
+    def feed_eof(self) -> Optional[_MsgT]:
+        if self._payload_parser is not None:
+            self._payload_parser.feed_eof()
+            self._payload_parser = None
+        else:
+            # try to extract partial message
+            if self._tail:
+                self._lines.append(self._tail)
+
+            if self._lines:
+                if self._lines[-1] != "\r\n":
+                    self._lines.append(b"")
+                with suppress(Exception):
+                    return self.parse_message(self._lines)
+        return None
+
+    def feed_data(
+        self,
+        data: bytes,
+        SEP: _SEP = b"\r\n",
+        EMPTY: bytes = b"",
+        CONTENT_LENGTH: istr = hdrs.CONTENT_LENGTH,
+        METH_CONNECT: str = hdrs.METH_CONNECT,
+        SEC_WEBSOCKET_KEY1: istr = hdrs.SEC_WEBSOCKET_KEY1,
+    ) -> Tuple[List[Tuple[_MsgT, StreamReader]], bool, bytes]:
+
+        messages = []
+
+        if self._tail:
+            data, self._tail = self._tail + data, b""
+
+        data_len = len(data)
+        start_pos = 0
+        loop = self.loop
+
+        while start_pos < data_len:
+
+            # read HTTP message (request/response line + headers), \r\n\r\n
+            # and split by lines
+            if self._payload_parser is None and not self._upgraded:
+                pos = data.find(SEP, start_pos)
+                # consume \r\n
+                if pos == start_pos and not self._lines:
+                    start_pos = pos + len(SEP)
+                    continue
+
+                if pos >= start_pos:
+                    # line found
+                    line = data[start_pos:pos]
+                    if SEP == b"\n":  # For lax response parsing
+                        line = line.rstrip(b"\r")
+                    self._lines.append(line)
+                    start_pos = pos + len(SEP)
+
+                    # \r\n\r\n found
+                    if self._lines[-1] == EMPTY:
+                        try:
+                            msg: _MsgT = self.parse_message(self._lines)
+                        finally:
+                            self._lines.clear()
+
+                        def get_content_length() -> Optional[int]:
+                            # payload length
+                            length_hdr = msg.headers.get(CONTENT_LENGTH)
+                            if length_hdr is None:
+                                return None
+
+                            # Shouldn't allow +/- or other number formats.
+                            # https://www.rfc-editor.org/rfc/rfc9110#section-8.6-2
+                            # msg.headers is already stripped of leading/trailing wsp
+                            if not DIGITS.fullmatch(length_hdr):
+                                raise InvalidHeader(CONTENT_LENGTH)
+
+                            return int(length_hdr)
+
+                        length = get_content_length()
+                        # do not support old websocket spec
+                        if SEC_WEBSOCKET_KEY1 in msg.headers:
+                            raise InvalidHeader(SEC_WEBSOCKET_KEY1)
+
+                        self._upgraded = msg.upgrade and _is_supported_upgrade(
+                            msg.headers
+                        )
+
+                        method = getattr(msg, "method", self.method)
+                        # code is only present on responses
+                        code = getattr(msg, "code", 0)
+
+                        assert self.protocol is not None
+                        # calculate payload
+                        empty_body = status_code_must_be_empty_body(code) or bool(
+                            method and method_must_be_empty_body(method)
+                        )
+                        if not empty_body and (
+                            ((length is not None and length > 0) or msg.chunked)
+                            and not self._upgraded
+                        ):
+                            payload = StreamReader(
+                                self.protocol,
+                                timer=self.timer,
+                                loop=loop,
+                                limit=self._limit,
+                            )
+                            payload_parser = HttpPayloadParser(
+                                payload,
+                                length=length,
+                                chunked=msg.chunked,
+                                method=method,
+                                compression=msg.compression,
+                                code=self.code,
+                                readall=self.readall,
+                                response_with_body=self.response_with_body,
+                                auto_decompress=self._auto_decompress,
+                                lax=self.lax,
+                            )
+                            if not payload_parser.done:
+                                self._payload_parser = payload_parser
+                        elif method == METH_CONNECT:
+                            assert isinstance(msg, RawRequestMessage)
+                            payload = StreamReader(
+                                self.protocol,
+                                timer=self.timer,
+                                loop=loop,
+                                limit=self._limit,
+                            )
+                            self._upgraded = True
+                            self._payload_parser = HttpPayloadParser(
+                                payload,
+                                method=msg.method,
+                                compression=msg.compression,
+                                readall=True,
+                                auto_decompress=self._auto_decompress,
+                                lax=self.lax,
+                            )
+                        elif not empty_body and length is None and self.read_until_eof:
+                            payload = StreamReader(
+                                self.protocol,
+                                timer=self.timer,
+                                loop=loop,
+                                limit=self._limit,
+                            )
+                            payload_parser = HttpPayloadParser(
+                                payload,
+                                length=length,
+                                chunked=msg.chunked,
+                                method=method,
+                                compression=msg.compression,
+                                code=self.code,
+                                readall=True,
+                                response_with_body=self.response_with_body,
+                                auto_decompress=self._auto_decompress,
+                                lax=self.lax,
+                            )
+                            if not payload_parser.done:
+                                self._payload_parser = payload_parser
+                        else:
+                            payload = EMPTY_PAYLOAD
+
+                        messages.append((msg, payload))
+                else:
+                    self._tail = data[start_pos:]
+                    data = EMPTY
+                    break
+
+            # no parser, just store
+            elif self._payload_parser is None and self._upgraded:
+                assert not self._lines
+                break
+
+            # feed payload
+            elif data and start_pos < data_len:
+                assert not self._lines
+                assert self._payload_parser is not None
+                try:
+                    eof, data = self._payload_parser.feed_data(data[start_pos:], SEP)
+                except BaseException as underlying_exc:
+                    reraised_exc = underlying_exc
+                    if self.payload_exception is not None:
+                        reraised_exc = self.payload_exception(str(underlying_exc))
+
+                    set_exception(
+                        self._payload_parser.payload,
+                        reraised_exc,
+                        underlying_exc,
+                    )
+
+                    eof = True
+                    data = b""
+
+                if eof:
+                    start_pos = 0
+                    data_len = len(data)
+                    self._payload_parser = None
+                    continue
+            else:
+                break
+
+        if data and start_pos < data_len:
+            data = data[start_pos:]
+        else:
+            data = EMPTY
+
+        return messages, self._upgraded, data
+
+    def parse_headers(
+        self, lines: List[bytes]
+    ) -> Tuple[
+        "CIMultiDictProxy[str]", RawHeaders, Optional[bool], Optional[str], bool, bool
+    ]:
+        """Parses RFC 5322 headers from a stream.
+
+        Line continuations are supported. Returns list of header name
+        and value pairs. Header name is in upper case.
+        """
+        headers, raw_headers = self._headers_parser.parse_headers(lines)
+        close_conn = None
+        encoding = None
+        upgrade = False
+        chunked = False
+
+        # https://www.rfc-editor.org/rfc/rfc9110.html#section-5.5-6
+        # https://www.rfc-editor.org/rfc/rfc9110.html#name-collected-abnf
+        singletons = (
+            hdrs.CONTENT_LENGTH,
+            hdrs.CONTENT_LOCATION,
+            hdrs.CONTENT_RANGE,
+            hdrs.CONTENT_TYPE,
+            hdrs.ETAG,
+            hdrs.HOST,
+            hdrs.MAX_FORWARDS,
+            hdrs.SERVER,
+            hdrs.TRANSFER_ENCODING,
+            hdrs.USER_AGENT,
+        )
+        bad_hdr = next((h for h in singletons if len(headers.getall(h, ())) > 1), None)
+        if bad_hdr is not None:
+            raise BadHttpMessage(f"Duplicate '{bad_hdr}' header found.")
+
+        # keep-alive
+        conn = headers.get(hdrs.CONNECTION)
+        if conn:
+            v = conn.lower()
+            if v == "close":
+                close_conn = True
+            elif v == "keep-alive":
+                close_conn = False
+            # https://www.rfc-editor.org/rfc/rfc9110.html#name-101-switching-protocols
+            elif v == "upgrade" and headers.get(hdrs.UPGRADE):
+                upgrade = True
+
+        # encoding
+        enc = headers.get(hdrs.CONTENT_ENCODING)
+        if enc:
+            enc = enc.lower()
+            if enc in ("gzip", "deflate", "br"):
+                encoding = enc
+
+        # chunking
+        te = headers.get(hdrs.TRANSFER_ENCODING)
+        if te is not None:
+            if "chunked" == te.lower():
+                chunked = True
+            else:
+                raise BadHttpMessage("Request has invalid `Transfer-Encoding`")
+
+            if hdrs.CONTENT_LENGTH in headers:
+                raise BadHttpMessage(
+                    "Transfer-Encoding can't be present with Content-Length",
+                )
+
+        return (headers, raw_headers, close_conn, encoding, upgrade, chunked)
+
+    def set_upgraded(self, val: bool) -> None:
+        """Set connection upgraded (to websocket) mode.
+
+        :param bool val: new state.
+        """
+        self._upgraded = val
+
+
+class HttpRequestParser(HttpParser[RawRequestMessage]):
+    """Read request status line.
+
+    Exception .http_exceptions.BadStatusLine
+    could be raised in case of any errors in status line.
+    Returns RawRequestMessage.
+    """
+
+    def parse_message(self, lines: List[bytes]) -> RawRequestMessage:
+        # request line
+        line = lines[0].decode("utf-8", "surrogateescape")
+        try:
+            method, path, version = line.split(" ", maxsplit=2)
+        except ValueError:
+            raise BadStatusLine(line) from None
+
+        if len(path) > self.max_line_size:
+            raise LineTooLong(
+                "Status line is too long", str(self.max_line_size), str(len(path))
+            )
+
+        # method
+        if not TOKENRE.fullmatch(method):
+            raise BadStatusLine(method)
+
+        # version
+        match = VERSRE.fullmatch(version)
+        if match is None:
+            raise BadStatusLine(line)
+        version_o = HttpVersion(int(match.group(1)), int(match.group(2)))
+
+        if method == "CONNECT":
+            # authority-form,
+            # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.3
+            url = URL.build(authority=path, encoded=True)
+        elif path.startswith("/"):
+            # origin-form,
+            # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.1
+            path_part, _hash_separator, url_fragment = path.partition("#")
+            path_part, _question_mark_separator, qs_part = path_part.partition("?")
+
+            # NOTE: `yarl.URL.build()` is used to mimic what the Cython-based
+            # NOTE: parser does, otherwise it results into the same
+            # NOTE: HTTP Request-Line input producing different
+            # NOTE: `yarl.URL()` objects
+            url = URL.build(
+                path=path_part,
+                query_string=qs_part,
+                fragment=url_fragment,
+                encoded=True,
+            )
+        elif path == "*" and method == "OPTIONS":
+            # asterisk-form,
+            url = URL(path, encoded=True)
+        else:
+            # absolute-form for proxy maybe,
+            # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.2
+            url = URL(path, encoded=True)
+            if url.scheme == "":
+                # not absolute-form
+                raise InvalidURLError(
+                    path.encode(errors="surrogateescape").decode("latin1")
+                )
+
+        # read headers
+        (
+            headers,
+            raw_headers,
+            close,
+            compression,
+            upgrade,
+            chunked,
+        ) = self.parse_headers(lines)
+
+        if close is None:  # then the headers weren't set in the request
+            if version_o <= HttpVersion10:  # HTTP 1.0 must asks to not close
+                close = True
+            else:  # HTTP 1.1 must ask to close.
+                close = False
+
+        return RawRequestMessage(
+            method,
+            path,
+            version_o,
+            headers,
+            raw_headers,
+            close,
+            compression,
+            upgrade,
+            chunked,
+            url,
+        )
+
+
+class HttpResponseParser(HttpParser[RawResponseMessage]):
+    """Read response status line and headers.
+
+    BadStatusLine could be raised in case of any errors in status line.
+    Returns RawResponseMessage.
+    """
+
+    # Lax mode should only be enabled on response parser.
+    lax = not DEBUG
+
+    def feed_data(
+        self,
+        data: bytes,
+        SEP: Optional[_SEP] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Tuple[List[Tuple[RawResponseMessage, StreamReader]], bool, bytes]:
+        if SEP is None:
+            SEP = b"\r\n" if DEBUG else b"\n"
+        return super().feed_data(data, SEP, *args, **kwargs)
+
+    def parse_message(self, lines: List[bytes]) -> RawResponseMessage:
+        line = lines[0].decode("utf-8", "surrogateescape")
+        try:
+            version, status = line.split(maxsplit=1)
+        except ValueError:
+            raise BadStatusLine(line) from None
+
+        try:
+            status, reason = status.split(maxsplit=1)
+        except ValueError:
+            status = status.strip()
+            reason = ""
+
+        if len(reason) > self.max_line_size:
+            raise LineTooLong(
+                "Status line is too long", str(self.max_line_size), str(len(reason))
+            )
+
+        # version
+        match = VERSRE.fullmatch(version)
+        if match is None:
+            raise BadStatusLine(line)
+        version_o = HttpVersion(int(match.group(1)), int(match.group(2)))
+
+        # The status code is a three-digit ASCII number, no padding
+        if len(status) != 3 or not DIGITS.fullmatch(status):
+            raise BadStatusLine(line)
+        status_i = int(status)
+
+        # read headers
+        (
+            headers,
+            raw_headers,
+            close,
+            compression,
+            upgrade,
+            chunked,
+        ) = self.parse_headers(lines)
+
+        if close is None:
+            if version_o <= HttpVersion10:
+                close = True
+            # https://www.rfc-editor.org/rfc/rfc9112.html#name-message-body-length
+            elif 100 <= status_i < 200 or status_i in {204, 304}:
+                close = False
+            elif hdrs.CONTENT_LENGTH in headers or hdrs.TRANSFER_ENCODING in headers:
+                close = False
+            else:
+                # https://www.rfc-editor.org/rfc/rfc9112.html#section-6.3-2.8
+                close = True
+
+        return RawResponseMessage(
+            version_o,
+            status_i,
+            reason.strip(),
+            headers,
+            raw_headers,
+            close,
+            compression,
+            upgrade,
+            chunked,
+        )
+
+
+class HttpPayloadParser:
+    def __init__(
+        self,
+        payload: StreamReader,
+        length: Optional[int] = None,
+        chunked: bool = False,
+        compression: Optional[str] = None,
+        code: Optional[int] = None,
+        method: Optional[str] = None,
+        readall: bool = False,
+        response_with_body: bool = True,
+        auto_decompress: bool = True,
+        lax: bool = False,
+    ) -> None:
+        self._length = 0
+        self._type = ParseState.PARSE_NONE
+        self._chunk = ChunkState.PARSE_CHUNKED_SIZE
+        self._chunk_size = 0
+        self._chunk_tail = b""
+        self._auto_decompress = auto_decompress
+        self._lax = lax
+        self.done = False
+
+        # payload decompression wrapper
+        if response_with_body and compression and self._auto_decompress:
+            real_payload: Union[StreamReader, DeflateBuffer] = DeflateBuffer(
+                payload, compression
+            )
+        else:
+            real_payload = payload
+
+        # payload parser
+        if not response_with_body:
+            # don't parse payload if it's not expected to be received
+            self._type = ParseState.PARSE_NONE
+            real_payload.feed_eof()
+            self.done = True
+
+        elif chunked:
+            self._type = ParseState.PARSE_CHUNKED
+        elif length is not None:
+            self._type = ParseState.PARSE_LENGTH
+            self._length = length
+            if self._length == 0:
+                real_payload.feed_eof()
+                self.done = True
+        else:
+            if readall and code != 204:
+                self._type = ParseState.PARSE_UNTIL_EOF
+            elif method in ("PUT", "POST"):
+                internal_logger.warning(  # pragma: no cover
+                    "Content-Length or Transfer-Encoding header is required"
+                )
+                self._type = ParseState.PARSE_NONE
+                real_payload.feed_eof()
+                self.done = True
+
+        self.payload = real_payload
+
+    def feed_eof(self) -> None:
+        if self._type == ParseState.PARSE_UNTIL_EOF:
+            self.payload.feed_eof()
+        elif self._type == ParseState.PARSE_LENGTH:
+            raise ContentLengthError(
+                "Not enough data for satisfy content length header."
+            )
+        elif self._type == ParseState.PARSE_CHUNKED:
+            raise TransferEncodingError(
+                "Not enough data for satisfy transfer length header."
+            )
+
+    def feed_data(
+        self, chunk: bytes, SEP: _SEP = b"\r\n", CHUNK_EXT: bytes = b";"
+    ) -> Tuple[bool, bytes]:
+        # Read specified amount of bytes
+        if self._type == ParseState.PARSE_LENGTH:
+            required = self._length
+            chunk_len = len(chunk)
+
+            if required >= chunk_len:
+                self._length = required - chunk_len
+                self.payload.feed_data(chunk, chunk_len)
+                if self._length == 0:
+                    self.payload.feed_eof()
+                    return True, b""
+            else:
+                self._length = 0
+                self.payload.feed_data(chunk[:required], required)
+                self.payload.feed_eof()
+                return True, chunk[required:]
+
+        # Chunked transfer encoding parser
+        elif self._type == ParseState.PARSE_CHUNKED:
+            if self._chunk_tail:
+                chunk = self._chunk_tail + chunk
+                self._chunk_tail = b""
+
+            while chunk:
+
+                # read next chunk size
+                if self._chunk == ChunkState.PARSE_CHUNKED_SIZE:
+                    pos = chunk.find(SEP)
+                    if pos >= 0:
+                        i = chunk.find(CHUNK_EXT, 0, pos)
+                        if i >= 0:
+                            size_b = chunk[:i]  # strip chunk-extensions
+                        else:
+                            size_b = chunk[:pos]
+
+                        if self._lax:  # Allow whitespace in lax mode.
+                            size_b = size_b.strip()
+
+                        if not re.fullmatch(HEXDIGITS, size_b):
+                            exc = TransferEncodingError(
+                                chunk[:pos].decode("ascii", "surrogateescape")
+                            )
+                            set_exception(self.payload, exc)
+                            raise exc
+                        size = int(bytes(size_b), 16)
+
+                        chunk = chunk[pos + len(SEP) :]
+                        if size == 0:  # eof marker
+                            self._chunk = ChunkState.PARSE_MAYBE_TRAILERS
+                            if self._lax and chunk.startswith(b"\r"):
+                                chunk = chunk[1:]
+                        else:
+                            self._chunk = ChunkState.PARSE_CHUNKED_CHUNK
+                            self._chunk_size = size
+                            self.payload.begin_http_chunk_receiving()
+                    else:
+                        self._chunk_tail = chunk
+                        return False, b""
+
+                # read chunk and feed buffer
+                if self._chunk == ChunkState.PARSE_CHUNKED_CHUNK:
+                    required = self._chunk_size
+                    chunk_len = len(chunk)
+
+                    if required > chunk_len:
+                        self._chunk_size = required - chunk_len
+                        self.payload.feed_data(chunk, chunk_len)
+                        return False, b""
+                    else:
+                        self._chunk_size = 0
+                        self.payload.feed_data(chunk[:required], required)
+                        chunk = chunk[required:]
+                        if self._lax and chunk.startswith(b"\r"):
+                            chunk = chunk[1:]
+                        self._chunk = ChunkState.PARSE_CHUNKED_CHUNK_EOF
+                        self.payload.end_http_chunk_receiving()
+
+                # toss the CRLF at the end of the chunk
+                if self._chunk == ChunkState.PARSE_CHUNKED_CHUNK_EOF:
+                    if chunk[: len(SEP)] == SEP:
+                        chunk = chunk[len(SEP) :]
+                        self._chunk = ChunkState.PARSE_CHUNKED_SIZE
+                    else:
+                        self._chunk_tail = chunk
+                        return False, b""
+
+                # if stream does not contain trailer, after 0\r\n
+                # we should get another \r\n otherwise
+                # trailers needs to be skipped until \r\n\r\n
+                if self._chunk == ChunkState.PARSE_MAYBE_TRAILERS:
+                    head = chunk[: len(SEP)]
+                    if head == SEP:
+                        # end of stream
+                        self.payload.feed_eof()
+                        return True, chunk[len(SEP) :]
+                    # Both CR and LF, or only LF may not be received yet. It is
+                    # expected that CRLF or LF will be shown at the very first
+                    # byte next time, otherwise trailers should come. The last
+                    # CRLF which marks the end of response might not be
+                    # contained in the same TCP segment which delivered the
+                    # size indicator.
+                    if not head:
+                        return False, b""
+                    if head == SEP[:1]:
+                        self._chunk_tail = head
+                        return False, b""
+                    self._chunk = ChunkState.PARSE_TRAILERS
+
+                # read and discard trailer up to the CRLF terminator
+                if self._chunk == ChunkState.PARSE_TRAILERS:
+                    pos = chunk.find(SEP)
+                    if pos >= 0:
+                        chunk = chunk[pos + len(SEP) :]
+                        self._chunk = ChunkState.PARSE_MAYBE_TRAILERS
+                    else:
+                        self._chunk_tail = chunk
+                        return False, b""
+
+        # Read all bytes until eof
+        elif self._type == ParseState.PARSE_UNTIL_EOF:
+            self.payload.feed_data(chunk, len(chunk))
+
+        return False, b""
+
+
+class DeflateBuffer:
+    """DeflateStream decompress stream and feed data into specified stream."""
+
+    decompressor: Any
+
+    def __init__(self, out: StreamReader, encoding: Optional[str]) -> None:
+        self.out = out
+        self.size = 0
+        self.encoding = encoding
+        self._started_decoding = False
+
+        self.decompressor: Union[BrotliDecompressor, ZLibDecompressor]
+        if encoding == "br":
+            if not HAS_BROTLI:  # pragma: no cover
+                raise ContentEncodingError(
+                    "Can not decode content-encoding: brotli (br). "
+                    "Please install `Brotli`"
+                )
+            self.decompressor = BrotliDecompressor()
+        else:
+            self.decompressor = ZLibDecompressor(encoding=encoding)
+
+    def set_exception(
+        self,
+        exc: BaseException,
+        exc_cause: BaseException = _EXC_SENTINEL,
+    ) -> None:
+        set_exception(self.out, exc, exc_cause)
+
+    def feed_data(self, chunk: bytes, size: int) -> None:
+        if not size:
+            return
+
+        self.size += size
+
+        # RFC1950
+        # bits 0..3 = CM = 0b1000 = 8 = "deflate"
+        # bits 4..7 = CINFO = 1..7 = windows size.
+        if (
+            not self._started_decoding
+            and self.encoding == "deflate"
+            and chunk[0] & 0xF != 8
+        ):
+            # Change the decoder to decompress incorrectly compressed data
+            # Actually we should issue a warning about non-RFC-compliant data.
+            self.decompressor = ZLibDecompressor(
+                encoding=self.encoding, suppress_deflate_header=True
+            )
+
+        try:
+            chunk = self.decompressor.decompress_sync(chunk)
+        except Exception:
+            raise ContentEncodingError(
+                "Can not decode content-encoding: %s" % self.encoding
+            )
+
+        self._started_decoding = True
+
+        if chunk:
+            self.out.feed_data(chunk, len(chunk))
+
+    def feed_eof(self) -> None:
+        chunk = self.decompressor.flush()
+
+        if chunk or self.size > 0:
+            self.out.feed_data(chunk, len(chunk))
+            if self.encoding == "deflate" and not self.decompressor.eof:
+                raise ContentEncodingError("deflate")
+
+        self.out.feed_eof()
+
+    def begin_http_chunk_receiving(self) -> None:
+        self.out.begin_http_chunk_receiving()
+
+    def end_http_chunk_receiving(self) -> None:
+        self.out.end_http_chunk_receiving()
+
+
+HttpRequestParserPy = HttpRequestParser
+HttpResponseParserPy = HttpResponseParser
+RawRequestMessagePy = RawRequestMessage
+RawResponseMessagePy = RawResponseMessage
+
+try:
+    if not NO_EXTENSIONS:
+        from ._http_parser import (  # type: ignore[import-not-found,no-redef]
+            HttpRequestParser,
+            HttpResponseParser,
+            RawRequestMessage,
+            RawResponseMessage,
+        )
+
+        HttpRequestParserC = HttpRequestParser
+        HttpResponseParserC = HttpResponseParser
+        RawRequestMessageC = RawRequestMessage
+        RawResponseMessageC = RawResponseMessage
+except ImportError:  # pragma: no cover
+    pass

env-llmeval/lib/python3.10/site-packages/aiohttp/http_websocket.py

@@ -0,0 +1,740 @@
+"""WebSocket protocol versions 13 and 8."""
+
+import asyncio
+import functools
+import json
+import random
+import re
+import sys
+import zlib
+from enum import IntEnum
+from struct import Struct
+from typing import (
+    Any,
+    Callable,
+    Final,
+    List,
+    NamedTuple,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
+
+from .base_protocol import BaseProtocol
+from .compression_utils import ZLibCompressor, ZLibDecompressor
+from .helpers import NO_EXTENSIONS, set_exception
+from .streams import DataQueue
+
+__all__ = (
+    "WS_CLOSED_MESSAGE",
+    "WS_CLOSING_MESSAGE",
+    "WS_KEY",
+    "WebSocketReader",
+    "WebSocketWriter",
+    "WSMessage",
+    "WebSocketError",
+    "WSMsgType",
+    "WSCloseCode",
+)
+
+
+class WSCloseCode(IntEnum):
+    OK = 1000
+    GOING_AWAY = 1001
+    PROTOCOL_ERROR = 1002
+    UNSUPPORTED_DATA = 1003
+    ABNORMAL_CLOSURE = 1006
+    INVALID_TEXT = 1007
+    POLICY_VIOLATION = 1008
+    MESSAGE_TOO_BIG = 1009
+    MANDATORY_EXTENSION = 1010
+    INTERNAL_ERROR = 1011
+    SERVICE_RESTART = 1012
+    TRY_AGAIN_LATER = 1013
+    BAD_GATEWAY = 1014
+
+
+ALLOWED_CLOSE_CODES: Final[Set[int]] = {int(i) for i in WSCloseCode}
+
+# For websockets, keeping latency low is extremely important as implementations
+# generally expect to be able to send and receive messages quickly.  We use a
+# larger chunk size than the default to reduce the number of executor calls
+# since the executor is a significant source of latency and overhead when
+# the chunks are small. A size of 5KiB was chosen because it is also the
+# same value python-zlib-ng choose to use as the threshold to release the GIL.
+
+WEBSOCKET_MAX_SYNC_CHUNK_SIZE = 5 * 1024
+
+
+class WSMsgType(IntEnum):
+    # websocket spec types
+    CONTINUATION = 0x0
+    TEXT = 0x1
+    BINARY = 0x2
+    PING = 0x9
+    PONG = 0xA
+    CLOSE = 0x8
+
+    # aiohttp specific types
+    CLOSING = 0x100
+    CLOSED = 0x101
+    ERROR = 0x102
+
+    text = TEXT
+    binary = BINARY
+    ping = PING
+    pong = PONG
+    close = CLOSE
+    closing = CLOSING
+    closed = CLOSED
+    error = ERROR
+
+
+WS_KEY: Final[bytes] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+
+UNPACK_LEN2 = Struct("!H").unpack_from
+UNPACK_LEN3 = Struct("!Q").unpack_from
+UNPACK_CLOSE_CODE = Struct("!H").unpack
+PACK_LEN1 = Struct("!BB").pack
+PACK_LEN2 = Struct("!BBH").pack
+PACK_LEN3 = Struct("!BBQ").pack
+PACK_CLOSE_CODE = Struct("!H").pack
+MSG_SIZE: Final[int] = 2**14
+DEFAULT_LIMIT: Final[int] = 2**16
+
+
+class WSMessage(NamedTuple):
+    type: WSMsgType
+    # To type correctly, this would need some kind of tagged union for each type.
+    data: Any
+    extra: Optional[str]
+
+    def json(self, *, loads: Callable[[Any], Any] = json.loads) -> Any:
+        """Return parsed JSON data.
+
+        .. versionadded:: 0.22
+        """
+        return loads(self.data)
+
+
+WS_CLOSED_MESSAGE = WSMessage(WSMsgType.CLOSED, None, None)
+WS_CLOSING_MESSAGE = WSMessage(WSMsgType.CLOSING, None, None)
+
+
+class WebSocketError(Exception):
+    """WebSocket protocol parser error."""
+
+    def __init__(self, code: int, message: str) -> None:
+        self.code = code
+        super().__init__(code, message)
+
+    def __str__(self) -> str:
+        return cast(str, self.args[1])
+
+
+class WSHandshakeError(Exception):
+    """WebSocket protocol handshake error."""
+
+
+native_byteorder: Final[str] = sys.byteorder
+
+
+# Used by _websocket_mask_python
+@functools.lru_cache
+def _xor_table() -> List[bytes]:
+    return [bytes(a ^ b for a in range(256)) for b in range(256)]
+
+
+def _websocket_mask_python(mask: bytes, data: bytearray) -> None:
+    """Websocket masking function.
+
+    `mask` is a `bytes` object of length 4; `data` is a `bytearray`
+    object of any length. The contents of `data` are masked with `mask`,
+    as specified in section 5.3 of RFC 6455.
+
+    Note that this function mutates the `data` argument.
+
+    This pure-python implementation may be replaced by an optimized
+    version when available.
+
+    """
+    assert isinstance(data, bytearray), data
+    assert len(mask) == 4, mask
+
+    if data:
+        _XOR_TABLE = _xor_table()
+        a, b, c, d = (_XOR_TABLE[n] for n in mask)
+        data[::4] = data[::4].translate(a)
+        data[1::4] = data[1::4].translate(b)
+        data[2::4] = data[2::4].translate(c)
+        data[3::4] = data[3::4].translate(d)
+
+
+if NO_EXTENSIONS:  # pragma: no cover
+    _websocket_mask = _websocket_mask_python
+else:
+    try:
+        from ._websocket import _websocket_mask_cython  # type: ignore[import-not-found]
+
+        _websocket_mask = _websocket_mask_cython
+    except ImportError:  # pragma: no cover
+        _websocket_mask = _websocket_mask_python
+
+_WS_DEFLATE_TRAILING: Final[bytes] = bytes([0x00, 0x00, 0xFF, 0xFF])
+
+
+_WS_EXT_RE: Final[Pattern[str]] = re.compile(
+    r"^(?:;\s*(?:"
+    r"(server_no_context_takeover)|"
+    r"(client_no_context_takeover)|"
+    r"(server_max_window_bits(?:=(\d+))?)|"
+    r"(client_max_window_bits(?:=(\d+))?)))*$"
+)
+
+_WS_EXT_RE_SPLIT: Final[Pattern[str]] = re.compile(r"permessage-deflate([^,]+)?")
+
+
+def ws_ext_parse(extstr: Optional[str], isserver: bool = False) -> Tuple[int, bool]:
+    if not extstr:
+        return 0, False
+
+    compress = 0
+    notakeover = False
+    for ext in _WS_EXT_RE_SPLIT.finditer(extstr):
+        defext = ext.group(1)
+        # Return compress = 15 when get `permessage-deflate`
+        if not defext:
+            compress = 15
+            break
+        match = _WS_EXT_RE.match(defext)
+        if match:
+            compress = 15
+            if isserver:
+                # Server never fail to detect compress handshake.
+                # Server does not need to send max wbit to client
+                if match.group(4):
+                    compress = int(match.group(4))
+                    # Group3 must match if group4 matches
+                    # Compress wbit 8 does not support in zlib
+                    # If compress level not support,
+                    # CONTINUE to next extension
+                    if compress > 15 or compress < 9:
+                        compress = 0
+                        continue
+                if match.group(1):
+                    notakeover = True
+                # Ignore regex group 5 & 6 for client_max_window_bits
+                break
+            else:
+                if match.group(6):
+                    compress = int(match.group(6))
+                    # Group5 must match if group6 matches
+                    # Compress wbit 8 does not support in zlib
+                    # If compress level not support,
+                    # FAIL the parse progress
+                    if compress > 15 or compress < 9:
+                        raise WSHandshakeError("Invalid window size")
+                if match.group(2):
+                    notakeover = True
+                # Ignore regex group 5 & 6 for client_max_window_bits
+                break
+        # Return Fail if client side and not match
+        elif not isserver:
+            raise WSHandshakeError("Extension for deflate not supported" + ext.group(1))
+
+    return compress, notakeover
+
+
+def ws_ext_gen(
+    compress: int = 15, isserver: bool = False, server_notakeover: bool = False
+) -> str:
+    # client_notakeover=False not used for server
+    # compress wbit 8 does not support in zlib
+    if compress < 9 or compress > 15:
+        raise ValueError(
+            "Compress wbits must between 9 and 15, " "zlib does not support wbits=8"
+        )
+    enabledext = ["permessage-deflate"]
+    if not isserver:
+        enabledext.append("client_max_window_bits")
+
+    if compress < 15:
+        enabledext.append("server_max_window_bits=" + str(compress))
+    if server_notakeover:
+        enabledext.append("server_no_context_takeover")
+    # if client_notakeover:
+    #     enabledext.append('client_no_context_takeover')
+    return "; ".join(enabledext)
+
+
+class WSParserState(IntEnum):
+    READ_HEADER = 1
+    READ_PAYLOAD_LENGTH = 2
+    READ_PAYLOAD_MASK = 3
+    READ_PAYLOAD = 4
+
+
+class WebSocketReader:
+    def __init__(
+        self, queue: DataQueue[WSMessage], max_msg_size: int, compress: bool = True
+    ) -> None:
+        self.queue = queue
+        self._max_msg_size = max_msg_size
+
+        self._exc: Optional[BaseException] = None
+        self._partial = bytearray()
+        self._state = WSParserState.READ_HEADER
+
+        self._opcode: Optional[int] = None
+        self._frame_fin = False
+        self._frame_opcode: Optional[int] = None
+        self._frame_payload = bytearray()
+
+        self._tail = b""
+        self._has_mask = False
+        self._frame_mask: Optional[bytes] = None
+        self._payload_length = 0
+        self._payload_length_flag = 0
+        self._compressed: Optional[bool] = None
+        self._decompressobj: Optional[ZLibDecompressor] = None
+        self._compress = compress
+
+    def feed_eof(self) -> None:
+        self.queue.feed_eof()
+
+    def feed_data(self, data: bytes) -> Tuple[bool, bytes]:
+        if self._exc:
+            return True, data
+
+        try:
+            return self._feed_data(data)
+        except Exception as exc:
+            self._exc = exc
+            set_exception(self.queue, exc)
+            return True, b""
+
+    def _feed_data(self, data: bytes) -> Tuple[bool, bytes]:
+        for fin, opcode, payload, compressed in self.parse_frame(data):
+            if compressed and not self._decompressobj:
+                self._decompressobj = ZLibDecompressor(suppress_deflate_header=True)
+            if opcode == WSMsgType.CLOSE:
+                if len(payload) >= 2:
+                    close_code = UNPACK_CLOSE_CODE(payload[:2])[0]
+                    if close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES:
+                        raise WebSocketError(
+                            WSCloseCode.PROTOCOL_ERROR,
+                            f"Invalid close code: {close_code}",
+                        )
+                    try:
+                        close_message = payload[2:].decode("utf-8")
+                    except UnicodeDecodeError as exc:
+                        raise WebSocketError(
+                            WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message"
+                        ) from exc
+                    msg = WSMessage(WSMsgType.CLOSE, close_code, close_message)
+                elif payload:
+                    raise WebSocketError(
+                        WSCloseCode.PROTOCOL_ERROR,
+                        f"Invalid close frame: {fin} {opcode} {payload!r}",
+                    )
+                else:
+                    msg = WSMessage(WSMsgType.CLOSE, 0, "")
+
+                self.queue.feed_data(msg, 0)
+
+            elif opcode == WSMsgType.PING:
+                self.queue.feed_data(
+                    WSMessage(WSMsgType.PING, payload, ""), len(payload)
+                )
+
+            elif opcode == WSMsgType.PONG:
+                self.queue.feed_data(
+                    WSMessage(WSMsgType.PONG, payload, ""), len(payload)
+                )
+
+            elif (
+                opcode not in (WSMsgType.TEXT, WSMsgType.BINARY)
+                and self._opcode is None
+            ):
+                raise WebSocketError(
+                    WSCloseCode.PROTOCOL_ERROR, f"Unexpected opcode={opcode!r}"
+                )
+            else:
+                # load text/binary
+                if not fin:
+                    # got partial frame payload
+                    if opcode != WSMsgType.CONTINUATION:
+                        self._opcode = opcode
+                    self._partial.extend(payload)
+                    if self._max_msg_size and len(self._partial) >= self._max_msg_size:
+                        raise WebSocketError(
+                            WSCloseCode.MESSAGE_TOO_BIG,
+                            "Message size {} exceeds limit {}".format(
+                                len(self._partial), self._max_msg_size
+                            ),
+                        )
+                else:
+                    # previous frame was non finished
+                    # we should get continuation opcode
+                    if self._partial:
+                        if opcode != WSMsgType.CONTINUATION:
+                            raise WebSocketError(
+                                WSCloseCode.PROTOCOL_ERROR,
+                                "The opcode in non-fin frame is expected "
+                                "to be zero, got {!r}".format(opcode),
+                            )
+
+                    if opcode == WSMsgType.CONTINUATION:
+                        assert self._opcode is not None
+                        opcode = self._opcode
+                        self._opcode = None
+
+                    self._partial.extend(payload)
+                    if self._max_msg_size and len(self._partial) >= self._max_msg_size:
+                        raise WebSocketError(
+                            WSCloseCode.MESSAGE_TOO_BIG,
+                            "Message size {} exceeds limit {}".format(
+                                len(self._partial), self._max_msg_size
+                            ),
+                        )
+
+                    # Decompress process must to be done after all packets
+                    # received.
+                    if compressed:
+                        assert self._decompressobj is not None
+                        self._partial.extend(_WS_DEFLATE_TRAILING)
+                        payload_merged = self._decompressobj.decompress_sync(
+                            self._partial, self._max_msg_size
+                        )
+                        if self._decompressobj.unconsumed_tail:
+                            left = len(self._decompressobj.unconsumed_tail)
+                            raise WebSocketError(
+                                WSCloseCode.MESSAGE_TOO_BIG,
+                                "Decompressed message size {} exceeds limit {}".format(
+                                    self._max_msg_size + left, self._max_msg_size
+                                ),
+                            )
+                    else:
+                        payload_merged = bytes(self._partial)
+
+                    self._partial.clear()
+
+                    if opcode == WSMsgType.TEXT:
+                        try:
+                            text = payload_merged.decode("utf-8")
+                            self.queue.feed_data(
+                                WSMessage(WSMsgType.TEXT, text, ""), len(text)
+                            )
+                        except UnicodeDecodeError as exc:
+                            raise WebSocketError(
+                                WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message"
+                            ) from exc
+                    else:
+                        self.queue.feed_data(
+                            WSMessage(WSMsgType.BINARY, payload_merged, ""),
+                            len(payload_merged),
+                        )
+
+        return False, b""
+
+    def parse_frame(
+        self, buf: bytes
+    ) -> List[Tuple[bool, Optional[int], bytearray, Optional[bool]]]:
+        """Return the next frame from the socket."""
+        frames = []
+        if self._tail:
+            buf, self._tail = self._tail + buf, b""
+
+        start_pos = 0
+        buf_length = len(buf)
+
+        while True:
+            # read header
+            if self._state == WSParserState.READ_HEADER:
+                if buf_length - start_pos >= 2:
+                    data = buf[start_pos : start_pos + 2]
+                    start_pos += 2
+                    first_byte, second_byte = data
+
+                    fin = (first_byte >> 7) & 1
+                    rsv1 = (first_byte >> 6) & 1
+                    rsv2 = (first_byte >> 5) & 1
+                    rsv3 = (first_byte >> 4) & 1
+                    opcode = first_byte & 0xF
+
+                    # frame-fin = %x0 ; more frames of this message follow
+                    #           / %x1 ; final frame of this message
+                    # frame-rsv1 = %x0 ;
+                    #    1 bit, MUST be 0 unless negotiated otherwise
+                    # frame-rsv2 = %x0 ;
+                    #    1 bit, MUST be 0 unless negotiated otherwise
+                    # frame-rsv3 = %x0 ;
+                    #    1 bit, MUST be 0 unless negotiated otherwise
+                    #
+                    # Remove rsv1 from this test for deflate development
+                    if rsv2 or rsv3 or (rsv1 and not self._compress):
+                        raise WebSocketError(
+                            WSCloseCode.PROTOCOL_ERROR,
+                            "Received frame with non-zero reserved bits",
+                        )
+
+                    if opcode > 0x7 and fin == 0:
+                        raise WebSocketError(
+                            WSCloseCode.PROTOCOL_ERROR,
+                            "Received fragmented control frame",
+                        )
+
+                    has_mask = (second_byte >> 7) & 1
+                    length = second_byte & 0x7F
+
+                    # Control frames MUST have a payload
+                    # length of 125 bytes or less
+                    if opcode > 0x7 and length > 125:
+                        raise WebSocketError(
+                            WSCloseCode.PROTOCOL_ERROR,
+                            "Control frame payload cannot be " "larger than 125 bytes",
+                        )
+
+                    # Set compress status if last package is FIN
+                    # OR set compress status if this is first fragment
+                    # Raise error if not first fragment with rsv1 = 0x1
+                    if self._frame_fin or self._compressed is None:
+                        self._compressed = True if rsv1 else False
+                    elif rsv1:
+                        raise WebSocketError(
+                            WSCloseCode.PROTOCOL_ERROR,
+                            "Received frame with non-zero reserved bits",
+                        )
+
+                    self._frame_fin = bool(fin)
+                    self._frame_opcode = opcode
+                    self._has_mask = bool(has_mask)
+                    self._payload_length_flag = length
+                    self._state = WSParserState.READ_PAYLOAD_LENGTH
+                else:
+                    break
+
+            # read payload length
+            if self._state == WSParserState.READ_PAYLOAD_LENGTH:
+                length = self._payload_length_flag
+                if length == 126:
+                    if buf_length - start_pos >= 2:
+                        data = buf[start_pos : start_pos + 2]
+                        start_pos += 2
+                        length = UNPACK_LEN2(data)[0]
+                        self._payload_length = length
+                        self._state = (
+                            WSParserState.READ_PAYLOAD_MASK
+                            if self._has_mask
+                            else WSParserState.READ_PAYLOAD
+                        )
+                    else:
+                        break
+                elif length > 126:
+                    if buf_length - start_pos >= 8:
+                        data = buf[start_pos : start_pos + 8]
+                        start_pos += 8
+                        length = UNPACK_LEN3(data)[0]
+                        self._payload_length = length
+                        self._state = (
+                            WSParserState.READ_PAYLOAD_MASK
+                            if self._has_mask
+                            else WSParserState.READ_PAYLOAD
+                        )
+                    else:
+                        break
+                else:
+                    self._payload_length = length
+                    self._state = (
+                        WSParserState.READ_PAYLOAD_MASK
+                        if self._has_mask
+                        else WSParserState.READ_PAYLOAD
+                    )
+
+            # read payload mask
+            if self._state == WSParserState.READ_PAYLOAD_MASK:
+                if buf_length - start_pos >= 4:
+                    self._frame_mask = buf[start_pos : start_pos + 4]
+                    start_pos += 4
+                    self._state = WSParserState.READ_PAYLOAD
+                else:
+                    break
+
+            if self._state == WSParserState.READ_PAYLOAD:
+                length = self._payload_length
+                payload = self._frame_payload
+
+                chunk_len = buf_length - start_pos
+                if length >= chunk_len:
+                    self._payload_length = length - chunk_len
+                    payload.extend(buf[start_pos:])
+                    start_pos = buf_length
+                else:
+                    self._payload_length = 0
+                    payload.extend(buf[start_pos : start_pos + length])
+                    start_pos = start_pos + length
+
+                if self._payload_length == 0:
+                    if self._has_mask:
+                        assert self._frame_mask is not None
+                        _websocket_mask(self._frame_mask, payload)
+
+                    frames.append(
+                        (self._frame_fin, self._frame_opcode, payload, self._compressed)
+                    )
+
+                    self._frame_payload = bytearray()
+                    self._state = WSParserState.READ_HEADER
+                else:
+                    break
+
+        self._tail = buf[start_pos:]
+
+        return frames
+
+
+class WebSocketWriter:
+    def __init__(
+        self,
+        protocol: BaseProtocol,
+        transport: asyncio.Transport,
+        *,
+        use_mask: bool = False,
+        limit: int = DEFAULT_LIMIT,
+        random: random.Random = random.Random(),
+        compress: int = 0,
+        notakeover: bool = False,
+    ) -> None:
+        self.protocol = protocol
+        self.transport = transport
+        self.use_mask = use_mask
+        self.randrange = random.randrange
+        self.compress = compress
+        self.notakeover = notakeover
+        self._closing = False
+        self._limit = limit
+        self._output_size = 0
+        self._compressobj: Any = None  # actually compressobj
+
+    async def _send_frame(
+        self, message: bytes, opcode: int, compress: Optional[int] = None
+    ) -> None:
+        """Send a frame over the websocket with message as its payload."""
+        if self._closing and not (opcode & WSMsgType.CLOSE):
+            raise ConnectionResetError("Cannot write to closing transport")
+
+        rsv = 0
+
+        # Only compress larger packets (disabled)
+        # Does small packet needs to be compressed?
+        # if self.compress and opcode < 8 and len(message) > 124:
+        if (compress or self.compress) and opcode < 8:
+            if compress:
+                # Do not set self._compress if compressing is for this frame
+                compressobj = self._make_compress_obj(compress)
+            else:  # self.compress
+                if not self._compressobj:
+                    self._compressobj = self._make_compress_obj(self.compress)
+                compressobj = self._compressobj
+
+            message = await compressobj.compress(message)
+            # Its critical that we do not return control to the event
+            # loop until we have finished sending all the compressed
+            # data. Otherwise we could end up mixing compressed frames
+            # if there are multiple coroutines compressing data.
+            message += compressobj.flush(
+                zlib.Z_FULL_FLUSH if self.notakeover else zlib.Z_SYNC_FLUSH
+            )
+            if message.endswith(_WS_DEFLATE_TRAILING):
+                message = message[:-4]
+            rsv = rsv | 0x40
+
+        msg_length = len(message)
+
+        use_mask = self.use_mask
+        if use_mask:
+            mask_bit = 0x80
+        else:
+            mask_bit = 0
+
+        if msg_length < 126:
+            header = PACK_LEN1(0x80 | rsv | opcode, msg_length | mask_bit)
+        elif msg_length < (1 << 16):
+            header = PACK_LEN2(0x80 | rsv | opcode, 126 | mask_bit, msg_length)
+        else:
+            header = PACK_LEN3(0x80 | rsv | opcode, 127 | mask_bit, msg_length)
+        if use_mask:
+            mask_int = self.randrange(0, 0xFFFFFFFF)
+            mask = mask_int.to_bytes(4, "big")
+            message = bytearray(message)
+            _websocket_mask(mask, message)
+            self._write(header + mask + message)
+            self._output_size += len(header) + len(mask) + msg_length
+        else:
+            if msg_length > MSG_SIZE:
+                self._write(header)
+                self._write(message)
+            else:
+                self._write(header + message)
+
+            self._output_size += len(header) + msg_length
+
+        # It is safe to return control to the event loop when using compression
+        # after this point as we have already sent or buffered all the data.
+
+        if self._output_size > self._limit:
+            self._output_size = 0
+            await self.protocol._drain_helper()
+
+    def _make_compress_obj(self, compress: int) -> ZLibCompressor:
+        return ZLibCompressor(
+            level=zlib.Z_BEST_SPEED,
+            wbits=-compress,
+            max_sync_chunk_size=WEBSOCKET_MAX_SYNC_CHUNK_SIZE,
+        )
+
+    def _write(self, data: bytes) -> None:
+        if self.transport is None or self.transport.is_closing():
+            raise ConnectionResetError("Cannot write to closing transport")
+        self.transport.write(data)
+
+    async def pong(self, message: Union[bytes, str] = b"") -> None:
+        """Send pong message."""
+        if isinstance(message, str):
+            message = message.encode("utf-8")
+        await self._send_frame(message, WSMsgType.PONG)
+
+    async def ping(self, message: Union[bytes, str] = b"") -> None:
+        """Send ping message."""
+        if isinstance(message, str):
+            message = message.encode("utf-8")
+        await self._send_frame(message, WSMsgType.PING)
+
+    async def send(
+        self,
+        message: Union[str, bytes],
+        binary: bool = False,
+        compress: Optional[int] = None,
+    ) -> None:
+        """Send a frame over the websocket with message as its payload."""
+        if isinstance(message, str):
+            message = message.encode("utf-8")
+        if binary:
+            await self._send_frame(message, WSMsgType.BINARY, compress)
+        else:
+            await self._send_frame(message, WSMsgType.TEXT, compress)
+
+    async def close(self, code: int = 1000, message: Union[bytes, str] = b"") -> None:
+        """Close the websocket, sending the specified code and message."""
+        if isinstance(message, str):
+            message = message.encode("utf-8")
+        try:
+            await self._send_frame(
+                PACK_CLOSE_CODE(code) + message, opcode=WSMsgType.CLOSE
+            )
+        finally:
+            self._closing = True

env-llmeval/lib/python3.10/site-packages/aiohttp/http_writer.py

@@ -0,0 +1,198 @@
+"""Http related parsers and protocol."""
+
+import asyncio
+import zlib
+from typing import Any, Awaitable, Callable, NamedTuple, Optional, Union  # noqa
+
+from multidict import CIMultiDict
+
+from .abc import AbstractStreamWriter
+from .base_protocol import BaseProtocol
+from .compression_utils import ZLibCompressor
+from .helpers import NO_EXTENSIONS
+
+__all__ = ("StreamWriter", "HttpVersion", "HttpVersion10", "HttpVersion11")
+
+
+class HttpVersion(NamedTuple):
+    major: int
+    minor: int
+
+
+HttpVersion10 = HttpVersion(1, 0)
+HttpVersion11 = HttpVersion(1, 1)
+
+
+_T_OnChunkSent = Optional[Callable[[bytes], Awaitable[None]]]
+_T_OnHeadersSent = Optional[Callable[["CIMultiDict[str]"], Awaitable[None]]]
+
+
+class StreamWriter(AbstractStreamWriter):
+    def __init__(
+        self,
+        protocol: BaseProtocol,
+        loop: asyncio.AbstractEventLoop,
+        on_chunk_sent: _T_OnChunkSent = None,
+        on_headers_sent: _T_OnHeadersSent = None,
+    ) -> None:
+        self._protocol = protocol
+
+        self.loop = loop
+        self.length = None
+        self.chunked = False
+        self.buffer_size = 0
+        self.output_size = 0
+
+        self._eof = False
+        self._compress: Optional[ZLibCompressor] = None
+        self._drain_waiter = None
+
+        self._on_chunk_sent: _T_OnChunkSent = on_chunk_sent
+        self._on_headers_sent: _T_OnHeadersSent = on_headers_sent
+
+    @property
+    def transport(self) -> Optional[asyncio.Transport]:
+        return self._protocol.transport
+
+    @property
+    def protocol(self) -> BaseProtocol:
+        return self._protocol
+
+    def enable_chunking(self) -> None:
+        self.chunked = True
+
+    def enable_compression(
+        self, encoding: str = "deflate", strategy: int = zlib.Z_DEFAULT_STRATEGY
+    ) -> None:
+        self._compress = ZLibCompressor(encoding=encoding, strategy=strategy)
+
+    def _write(self, chunk: bytes) -> None:
+        size = len(chunk)
+        self.buffer_size += size
+        self.output_size += size
+        transport = self.transport
+        if not self._protocol.connected or transport is None or transport.is_closing():
+            raise ConnectionResetError("Cannot write to closing transport")
+        transport.write(chunk)
+
+    async def write(
+        self, chunk: bytes, *, drain: bool = True, LIMIT: int = 0x10000
+    ) -> None:
+        """Writes chunk of data to a stream.
+
+        write_eof() indicates end of stream.
+        writer can't be used after write_eof() method being called.
+        write() return drain future.
+        """
+        if self._on_chunk_sent is not None:
+            await self._on_chunk_sent(chunk)
+
+        if isinstance(chunk, memoryview):
+            if chunk.nbytes != len(chunk):
+                # just reshape it
+                chunk = chunk.cast("c")
+
+        if self._compress is not None:
+            chunk = await self._compress.compress(chunk)
+            if not chunk:
+                return
+
+        if self.length is not None:
+            chunk_len = len(chunk)
+            if self.length >= chunk_len:
+                self.length = self.length - chunk_len
+            else:
+                chunk = chunk[: self.length]
+                self.length = 0
+                if not chunk:
+                    return
+
+        if chunk:
+            if self.chunked:
+                chunk_len_pre = ("%x\r\n" % len(chunk)).encode("ascii")
+                chunk = chunk_len_pre + chunk + b"\r\n"
+
+            self._write(chunk)
+
+            if self.buffer_size > LIMIT and drain:
+                self.buffer_size = 0
+                await self.drain()
+
+    async def write_headers(
+        self, status_line: str, headers: "CIMultiDict[str]"
+    ) -> None:
+        """Write request/response status and headers."""
+        if self._on_headers_sent is not None:
+            await self._on_headers_sent(headers)
+
+        # status + headers
+        buf = _serialize_headers(status_line, headers)
+        self._write(buf)
+
+    async def write_eof(self, chunk: bytes = b"") -> None:
+        if self._eof:
+            return
+
+        if chunk and self._on_chunk_sent is not None:
+            await self._on_chunk_sent(chunk)
+
+        if self._compress:
+            if chunk:
+                chunk = await self._compress.compress(chunk)
+
+            chunk += self._compress.flush()
+            if chunk and self.chunked:
+                chunk_len = ("%x\r\n" % len(chunk)).encode("ascii")
+                chunk = chunk_len + chunk + b"\r\n0\r\n\r\n"
+        else:
+            if self.chunked:
+                if chunk:
+                    chunk_len = ("%x\r\n" % len(chunk)).encode("ascii")
+                    chunk = chunk_len + chunk + b"\r\n0\r\n\r\n"
+                else:
+                    chunk = b"0\r\n\r\n"
+
+        if chunk:
+            self._write(chunk)
+
+        await self.drain()
+
+        self._eof = True
+
+    async def drain(self) -> None:
+        """Flush the write buffer.
+
+        The intended use is to write
+
+          await w.write(data)
+          await w.drain()
+        """
+        if self._protocol.transport is not None:
+            await self._protocol._drain_helper()
+
+
+def _safe_header(string: str) -> str:
+    if "\r" in string or "\n" in string:
+        raise ValueError(
+            "Newline or carriage return detected in headers. "
+            "Potential header injection attack."
+        )
+    return string
+
+
+def _py_serialize_headers(status_line: str, headers: "CIMultiDict[str]") -> bytes:
+    headers_gen = (_safe_header(k) + ": " + _safe_header(v) for k, v in headers.items())
+    line = status_line + "\r\n" + "\r\n".join(headers_gen) + "\r\n\r\n"
+    return line.encode("utf-8")
+
+
+_serialize_headers = _py_serialize_headers
+
+try:
+    import aiohttp._http_writer as _http_writer  # type: ignore[import-not-found]
+
+    _c_serialize_headers = _http_writer._serialize_headers
+    if not NO_EXTENSIONS:
+        _serialize_headers = _c_serialize_headers
+except ImportError:
+    pass

env-llmeval/lib/python3.10/site-packages/aiohttp/locks.py

@@ -0,0 +1,41 @@
+import asyncio
+import collections
+from typing import Any, Deque, Optional
+
+
+class EventResultOrError:
+    """Event asyncio lock helper class.
+
+    Wraps the Event asyncio lock allowing either to awake the
+    locked Tasks without any error or raising an exception.
+
+    thanks to @vorpalsmith for the simple design.
+    """
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._exc: Optional[BaseException] = None
+        self._event = asyncio.Event()
+        self._waiters: Deque[asyncio.Future[Any]] = collections.deque()
+
+    def set(self, exc: Optional[BaseException] = None) -> None:
+        self._exc = exc
+        self._event.set()
+
+    async def wait(self) -> Any:
+        waiter = self._loop.create_task(self._event.wait())
+        self._waiters.append(waiter)
+        try:
+            val = await waiter
+        finally:
+            self._waiters.remove(waiter)
+
+        if self._exc is not None:
+            raise self._exc
+
+        return val
+
+    def cancel(self) -> None:
+        """Cancel all waiters"""
+        for waiter in self._waiters:
+            waiter.cancel()

env-llmeval/lib/python3.10/site-packages/aiohttp/log.py

@@ -0,0 +1,8 @@
+import logging
+
+access_logger = logging.getLogger("aiohttp.access")
+client_logger = logging.getLogger("aiohttp.client")
+internal_logger = logging.getLogger("aiohttp.internal")
+server_logger = logging.getLogger("aiohttp.server")
+web_logger = logging.getLogger("aiohttp.web")
+ws_logger = logging.getLogger("aiohttp.websocket")

env-llmeval/lib/python3.10/site-packages/aiohttp/multipart.py

@@ -0,0 +1,1008 @@
+import base64
+import binascii
+import json
+import re
+import uuid
+import warnings
+import zlib
+from collections import deque
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterator,
+    Deque,
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+from urllib.parse import parse_qsl, unquote, urlencode
+
+from multidict import CIMultiDict, CIMultiDictProxy
+
+from .compression_utils import ZLibCompressor, ZLibDecompressor
+from .hdrs import (
+    CONTENT_DISPOSITION,
+    CONTENT_ENCODING,
+    CONTENT_LENGTH,
+    CONTENT_TRANSFER_ENCODING,
+    CONTENT_TYPE,
+)
+from .helpers import CHAR, TOKEN, parse_mimetype, reify
+from .http import HeadersParser
+from .payload import (
+    JsonPayload,
+    LookupError,
+    Order,
+    Payload,
+    StringPayload,
+    get_payload,
+    payload_type,
+)
+from .streams import StreamReader
+
+__all__ = (
+    "MultipartReader",
+    "MultipartWriter",
+    "BodyPartReader",
+    "BadContentDispositionHeader",
+    "BadContentDispositionParam",
+    "parse_content_disposition",
+    "content_disposition_filename",
+)
+
+
+if TYPE_CHECKING:
+    from .client_reqrep import ClientResponse
+
+
+class BadContentDispositionHeader(RuntimeWarning):
+    pass
+
+
+class BadContentDispositionParam(RuntimeWarning):
+    pass
+
+
+def parse_content_disposition(
+    header: Optional[str],
+) -> Tuple[Optional[str], Dict[str, str]]:
+    def is_token(string: str) -> bool:
+        return bool(string) and TOKEN >= set(string)
+
+    def is_quoted(string: str) -> bool:
+        return string[0] == string[-1] == '"'
+
+    def is_rfc5987(string: str) -> bool:
+        return is_token(string) and string.count("'") == 2
+
+    def is_extended_param(string: str) -> bool:
+        return string.endswith("*")
+
+    def is_continuous_param(string: str) -> bool:
+        pos = string.find("*") + 1
+        if not pos:
+            return False
+        substring = string[pos:-1] if string.endswith("*") else string[pos:]
+        return substring.isdigit()
+
+    def unescape(text: str, *, chars: str = "".join(map(re.escape, CHAR))) -> str:
+        return re.sub(f"\\\\([{chars}])", "\\1", text)
+
+    if not header:
+        return None, {}
+
+    disptype, *parts = header.split(";")
+    if not is_token(disptype):
+        warnings.warn(BadContentDispositionHeader(header))
+        return None, {}
+
+    params: Dict[str, str] = {}
+    while parts:
+        item = parts.pop(0)
+
+        if "=" not in item:
+            warnings.warn(BadContentDispositionHeader(header))
+            return None, {}
+
+        key, value = item.split("=", 1)
+        key = key.lower().strip()
+        value = value.lstrip()
+
+        if key in params:
+            warnings.warn(BadContentDispositionHeader(header))
+            return None, {}
+
+        if not is_token(key):
+            warnings.warn(BadContentDispositionParam(item))
+            continue
+
+        elif is_continuous_param(key):
+            if is_quoted(value):
+                value = unescape(value[1:-1])
+            elif not is_token(value):
+                warnings.warn(BadContentDispositionParam(item))
+                continue
+
+        elif is_extended_param(key):
+            if is_rfc5987(value):
+                encoding, _, value = value.split("'", 2)
+                encoding = encoding or "utf-8"
+            else:
+                warnings.warn(BadContentDispositionParam(item))
+                continue
+
+            try:
+                value = unquote(value, encoding, "strict")
+            except UnicodeDecodeError:  # pragma: nocover
+                warnings.warn(BadContentDispositionParam(item))
+                continue
+
+        else:
+            failed = True
+            if is_quoted(value):
+                failed = False
+                value = unescape(value[1:-1].lstrip("\\/"))
+            elif is_token(value):
+                failed = False
+            elif parts:
+                # maybe just ; in filename, in any case this is just
+                # one case fix, for proper fix we need to redesign parser
+                _value = f"{value};{parts[0]}"
+                if is_quoted(_value):
+                    parts.pop(0)
+                    value = unescape(_value[1:-1].lstrip("\\/"))
+                    failed = False
+
+            if failed:
+                warnings.warn(BadContentDispositionHeader(header))
+                return None, {}
+
+        params[key] = value
+
+    return disptype.lower(), params
+
+
+def content_disposition_filename(
+    params: Mapping[str, str], name: str = "filename"
+) -> Optional[str]:
+    name_suf = "%s*" % name
+    if not params:
+        return None
+    elif name_suf in params:
+        return params[name_suf]
+    elif name in params:
+        return params[name]
+    else:
+        parts = []
+        fnparams = sorted(
+            (key, value) for key, value in params.items() if key.startswith(name_suf)
+        )
+        for num, (key, value) in enumerate(fnparams):
+            _, tail = key.split("*", 1)
+            if tail.endswith("*"):
+                tail = tail[:-1]
+            if tail == str(num):
+                parts.append(value)
+            else:
+                break
+        if not parts:
+            return None
+        value = "".join(parts)
+        if "'" in value:
+            encoding, _, value = value.split("'", 2)
+            encoding = encoding or "utf-8"
+            return unquote(value, encoding, "strict")
+        return value
+
+
+class MultipartResponseWrapper:
+    """Wrapper around the MultipartReader.
+
+    It takes care about
+    underlying connection and close it when it needs in.
+    """
+
+    def __init__(
+        self,
+        resp: "ClientResponse",
+        stream: "MultipartReader",
+    ) -> None:
+        self.resp = resp
+        self.stream = stream
+
+    def __aiter__(self) -> "MultipartResponseWrapper":
+        return self
+
+    async def __anext__(
+        self,
+    ) -> Union["MultipartReader", "BodyPartReader"]:
+        part = await self.next()
+        if part is None:
+            raise StopAsyncIteration
+        return part
+
+    def at_eof(self) -> bool:
+        """Returns True when all response data had been read."""
+        return self.resp.content.at_eof()
+
+    async def next(
+        self,
+    ) -> Optional[Union["MultipartReader", "BodyPartReader"]]:
+        """Emits next multipart reader object."""
+        item = await self.stream.next()
+        if self.stream.at_eof():
+            await self.release()
+        return item
+
+    async def release(self) -> None:
+        """Release the connection gracefully.
+
+        All remaining content is read to the void.
+        """
+        await self.resp.release()
+
+
+class BodyPartReader:
+    """Multipart reader for single body part."""
+
+    chunk_size = 8192
+
+    def __init__(
+        self,
+        boundary: bytes,
+        headers: "CIMultiDictProxy[str]",
+        content: StreamReader,
+        *,
+        subtype: str = "mixed",
+        default_charset: Optional[str] = None,
+    ) -> None:
+        self.headers = headers
+        self._boundary = boundary
+        self._content = content
+        self._default_charset = default_charset
+        self._at_eof = False
+        self._is_form_data = subtype == "form-data"
+        # https://datatracker.ietf.org/doc/html/rfc7578#section-4.8
+        length = None if self._is_form_data else self.headers.get(CONTENT_LENGTH, None)
+        self._length = int(length) if length is not None else None
+        self._read_bytes = 0
+        self._unread: Deque[bytes] = deque()
+        self._prev_chunk: Optional[bytes] = None
+        self._content_eof = 0
+        self._cache: Dict[str, Any] = {}
+
+    def __aiter__(self) -> AsyncIterator["BodyPartReader"]:
+        return self  # type: ignore[return-value]
+
+    async def __anext__(self) -> bytes:
+        part = await self.next()
+        if part is None:
+            raise StopAsyncIteration
+        return part
+
+    async def next(self) -> Optional[bytes]:
+        item = await self.read()
+        if not item:
+            return None
+        return item
+
+    async def read(self, *, decode: bool = False) -> bytes:
+        """Reads body part data.
+
+        decode: Decodes data following by encoding
+                method from Content-Encoding header. If it missed
+                data remains untouched
+        """
+        if self._at_eof:
+            return b""
+        data = bytearray()
+        while not self._at_eof:
+            data.extend(await self.read_chunk(self.chunk_size))
+        if decode:
+            return self.decode(data)
+        return data
+
+    async def read_chunk(self, size: int = chunk_size) -> bytes:
+        """Reads body part content chunk of the specified size.
+
+        size: chunk size
+        """
+        if self._at_eof:
+            return b""
+        if self._length:
+            chunk = await self._read_chunk_from_length(size)
+        else:
+            chunk = await self._read_chunk_from_stream(size)
+
+        self._read_bytes += len(chunk)
+        if self._read_bytes == self._length:
+            self._at_eof = True
+        if self._at_eof:
+            clrf = await self._content.readline()
+            assert (
+                b"\r\n" == clrf
+            ), "reader did not read all the data or it is malformed"
+        return chunk
+
+    async def _read_chunk_from_length(self, size: int) -> bytes:
+        # Reads body part content chunk of the specified size.
+        # The body part must has Content-Length header with proper value.
+        assert self._length is not None, "Content-Length required for chunked read"
+        chunk_size = min(size, self._length - self._read_bytes)
+        chunk = await self._content.read(chunk_size)
+        if self._content.at_eof():
+            self._at_eof = True
+        return chunk
+
+    async def _read_chunk_from_stream(self, size: int) -> bytes:
+        # Reads content chunk of body part with unknown length.
+        # The Content-Length header for body part is not necessary.
+        assert (
+            size >= len(self._boundary) + 2
+        ), "Chunk size must be greater or equal than boundary length + 2"
+        first_chunk = self._prev_chunk is None
+        if first_chunk:
+            self._prev_chunk = await self._content.read(size)
+
+        chunk = await self._content.read(size)
+        self._content_eof += int(self._content.at_eof())
+        assert self._content_eof < 3, "Reading after EOF"
+        assert self._prev_chunk is not None
+        window = self._prev_chunk + chunk
+        sub = b"\r\n" + self._boundary
+        if first_chunk:
+            idx = window.find(sub)
+        else:
+            idx = window.find(sub, max(0, len(self._prev_chunk) - len(sub)))
+        if idx >= 0:
+            # pushing boundary back to content
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=DeprecationWarning)
+                self._content.unread_data(window[idx:])
+            if size > idx:
+                self._prev_chunk = self._prev_chunk[:idx]
+            chunk = window[len(self._prev_chunk) : idx]
+            if not chunk:
+                self._at_eof = True
+        result = self._prev_chunk
+        self._prev_chunk = chunk
+        return result
+
+    async def readline(self) -> bytes:
+        """Reads body part by line by line."""
+        if self._at_eof:
+            return b""
+
+        if self._unread:
+            line = self._unread.popleft()
+        else:
+            line = await self._content.readline()
+
+        if line.startswith(self._boundary):
+            # the very last boundary may not come with \r\n,
+            # so set single rules for everyone
+            sline = line.rstrip(b"\r\n")
+            boundary = self._boundary
+            last_boundary = self._boundary + b"--"
+            # ensure that we read exactly the boundary, not something alike
+            if sline == boundary or sline == last_boundary:
+                self._at_eof = True
+                self._unread.append(line)
+                return b""
+        else:
+            next_line = await self._content.readline()
+            if next_line.startswith(self._boundary):
+                line = line[:-2]  # strip CRLF but only once
+            self._unread.append(next_line)
+
+        return line
+
+    async def release(self) -> None:
+        """Like read(), but reads all the data to the void."""
+        if self._at_eof:
+            return
+        while not self._at_eof:
+            await self.read_chunk(self.chunk_size)
+
+    async def text(self, *, encoding: Optional[str] = None) -> str:
+        """Like read(), but assumes that body part contains text data."""
+        data = await self.read(decode=True)
+        # see https://www.w3.org/TR/html5/forms.html#multipart/form-data-encoding-algorithm
+        # and https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#dom-xmlhttprequest-send
+        encoding = encoding or self.get_charset(default="utf-8")
+        return data.decode(encoding)
+
+    async def json(self, *, encoding: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Like read(), but assumes that body parts contains JSON data."""
+        data = await self.read(decode=True)
+        if not data:
+            return None
+        encoding = encoding or self.get_charset(default="utf-8")
+        return cast(Dict[str, Any], json.loads(data.decode(encoding)))
+
+    async def form(self, *, encoding: Optional[str] = None) -> List[Tuple[str, str]]:
+        """Like read(), but assumes that body parts contain form urlencoded data."""
+        data = await self.read(decode=True)
+        if not data:
+            return []
+        if encoding is not None:
+            real_encoding = encoding
+        else:
+            real_encoding = self.get_charset(default="utf-8")
+        try:
+            decoded_data = data.rstrip().decode(real_encoding)
+        except UnicodeDecodeError:
+            raise ValueError("data cannot be decoded with %s encoding" % real_encoding)
+
+        return parse_qsl(
+            decoded_data,
+            keep_blank_values=True,
+            encoding=real_encoding,
+        )
+
+    def at_eof(self) -> bool:
+        """Returns True if the boundary was reached or False otherwise."""
+        return self._at_eof
+
+    def decode(self, data: bytes) -> bytes:
+        """Decodes data.
+
+        Decoding is done according the specified Content-Encoding
+        or Content-Transfer-Encoding headers value.
+        """
+        if CONTENT_TRANSFER_ENCODING in self.headers:
+            data = self._decode_content_transfer(data)
+        # https://datatracker.ietf.org/doc/html/rfc7578#section-4.8
+        if not self._is_form_data and CONTENT_ENCODING in self.headers:
+            return self._decode_content(data)
+        return data
+
+    def _decode_content(self, data: bytes) -> bytes:
+        encoding = self.headers.get(CONTENT_ENCODING, "").lower()
+        if encoding == "identity":
+            return data
+        if encoding in {"deflate", "gzip"}:
+            return ZLibDecompressor(
+                encoding=encoding,
+                suppress_deflate_header=True,
+            ).decompress_sync(data)
+
+        raise RuntimeError(f"unknown content encoding: {encoding}")
+
+    def _decode_content_transfer(self, data: bytes) -> bytes:
+        encoding = self.headers.get(CONTENT_TRANSFER_ENCODING, "").lower()
+
+        if encoding == "base64":
+            return base64.b64decode(data)
+        elif encoding == "quoted-printable":
+            return binascii.a2b_qp(data)
+        elif encoding in ("binary", "8bit", "7bit"):
+            return data
+        else:
+            raise RuntimeError(
+                "unknown content transfer encoding: {}" "".format(encoding)
+            )
+
+    def get_charset(self, default: str) -> str:
+        """Returns charset parameter from Content-Type header or default."""
+        ctype = self.headers.get(CONTENT_TYPE, "")
+        mimetype = parse_mimetype(ctype)
+        return mimetype.parameters.get("charset", self._default_charset or default)
+
+    @reify
+    def name(self) -> Optional[str]:
+        """Returns name specified in Content-Disposition header.
+
+        If the header is missing or malformed, returns None.
+        """
+        _, params = parse_content_disposition(self.headers.get(CONTENT_DISPOSITION))
+        return content_disposition_filename(params, "name")
+
+    @reify
+    def filename(self) -> Optional[str]:
+        """Returns filename specified in Content-Disposition header.
+
+        Returns None if the header is missing or malformed.
+        """
+        _, params = parse_content_disposition(self.headers.get(CONTENT_DISPOSITION))
+        return content_disposition_filename(params, "filename")
+
+
+@payload_type(BodyPartReader, order=Order.try_first)
+class BodyPartReaderPayload(Payload):
+    def __init__(self, value: BodyPartReader, *args: Any, **kwargs: Any) -> None:
+        super().__init__(value, *args, **kwargs)
+
+        params: Dict[str, str] = {}
+        if value.name is not None:
+            params["name"] = value.name
+        if value.filename is not None:
+            params["filename"] = value.filename
+
+        if params:
+            self.set_content_disposition("attachment", True, **params)
+
+    async def write(self, writer: Any) -> None:
+        field = self._value
+        chunk = await field.read_chunk(size=2**16)
+        while chunk:
+            await writer.write(field.decode(chunk))
+            chunk = await field.read_chunk(size=2**16)
+
+
+class MultipartReader:
+    """Multipart body reader."""
+
+    #: Response wrapper, used when multipart readers constructs from response.
+    response_wrapper_cls = MultipartResponseWrapper
+    #: Multipart reader class, used to handle multipart/* body parts.
+    #: None points to type(self)
+    multipart_reader_cls = None
+    #: Body part reader class for non multipart/* content types.
+    part_reader_cls = BodyPartReader
+
+    def __init__(self, headers: Mapping[str, str], content: StreamReader) -> None:
+        self._mimetype = parse_mimetype(headers[CONTENT_TYPE])
+        assert self._mimetype.type == "multipart", "multipart/* content type expected"
+        if "boundary" not in self._mimetype.parameters:
+            raise ValueError(
+                "boundary missed for Content-Type: %s" % headers[CONTENT_TYPE]
+            )
+
+        self.headers = headers
+        self._boundary = ("--" + self._get_boundary()).encode()
+        self._content = content
+        self._default_charset: Optional[str] = None
+        self._last_part: Optional[Union["MultipartReader", BodyPartReader]] = None
+        self._at_eof = False
+        self._at_bof = True
+        self._unread: List[bytes] = []
+
+    def __aiter__(
+        self,
+    ) -> AsyncIterator["BodyPartReader"]:
+        return self  # type: ignore[return-value]
+
+    async def __anext__(
+        self,
+    ) -> Optional[Union["MultipartReader", BodyPartReader]]:
+        part = await self.next()
+        if part is None:
+            raise StopAsyncIteration
+        return part
+
+    @classmethod
+    def from_response(
+        cls,
+        response: "ClientResponse",
+    ) -> MultipartResponseWrapper:
+        """Constructs reader instance from HTTP response.
+
+        :param response: :class:`~aiohttp.client.ClientResponse` instance
+        """
+        obj = cls.response_wrapper_cls(
+            response, cls(response.headers, response.content)
+        )
+        return obj
+
+    def at_eof(self) -> bool:
+        """Returns True if the final boundary was reached, false otherwise."""
+        return self._at_eof
+
+    async def next(
+        self,
+    ) -> Optional[Union["MultipartReader", BodyPartReader]]:
+        """Emits the next multipart body part."""
+        # So, if we're at BOF, we need to skip till the boundary.
+        if self._at_eof:
+            return None
+        await self._maybe_release_last_part()
+        if self._at_bof:
+            await self._read_until_first_boundary()
+            self._at_bof = False
+        else:
+            await self._read_boundary()
+        if self._at_eof:  # we just read the last boundary, nothing to do there
+            return None
+
+        part = await self.fetch_next_part()
+        # https://datatracker.ietf.org/doc/html/rfc7578#section-4.6
+        if (
+            self._last_part is None
+            and self._mimetype.subtype == "form-data"
+            and isinstance(part, BodyPartReader)
+        ):
+            _, params = parse_content_disposition(part.headers.get(CONTENT_DISPOSITION))
+            if params.get("name") == "_charset_":
+                # Longest encoding in https://encoding.spec.whatwg.org/encodings.json
+                # is 19 characters, so 32 should be more than enough for any valid encoding.
+                charset = await part.read_chunk(32)
+                if len(charset) > 31:
+                    raise RuntimeError("Invalid default charset")
+                self._default_charset = charset.strip().decode()
+                part = await self.fetch_next_part()
+        self._last_part = part
+        return self._last_part
+
+    async def release(self) -> None:
+        """Reads all the body parts to the void till the final boundary."""
+        while not self._at_eof:
+            item = await self.next()
+            if item is None:
+                break
+            await item.release()
+
+    async def fetch_next_part(
+        self,
+    ) -> Union["MultipartReader", BodyPartReader]:
+        """Returns the next body part reader."""
+        headers = await self._read_headers()
+        return self._get_part_reader(headers)
+
+    def _get_part_reader(
+        self,
+        headers: "CIMultiDictProxy[str]",
+    ) -> Union["MultipartReader", BodyPartReader]:
+        """Dispatches the response by the `Content-Type` header.
+
+        Returns a suitable reader instance.
+
+        :param dict headers: Response headers
+        """
+        ctype = headers.get(CONTENT_TYPE, "")
+        mimetype = parse_mimetype(ctype)
+
+        if mimetype.type == "multipart":
+            if self.multipart_reader_cls is None:
+                return type(self)(headers, self._content)
+            return self.multipart_reader_cls(headers, self._content)
+        else:
+            return self.part_reader_cls(
+                self._boundary,
+                headers,
+                self._content,
+                subtype=self._mimetype.subtype,
+                default_charset=self._default_charset,
+            )
+
+    def _get_boundary(self) -> str:
+        boundary = self._mimetype.parameters["boundary"]
+        if len(boundary) > 70:
+            raise ValueError("boundary %r is too long (70 chars max)" % boundary)
+
+        return boundary
+
+    async def _readline(self) -> bytes:
+        if self._unread:
+            return self._unread.pop()
+        return await self._content.readline()
+
+    async def _read_until_first_boundary(self) -> None:
+        while True:
+            chunk = await self._readline()
+            if chunk == b"":
+                raise ValueError(
+                    "Could not find starting boundary %r" % (self._boundary)
+                )
+            chunk = chunk.rstrip()
+            if chunk == self._boundary:
+                return
+            elif chunk == self._boundary + b"--":
+                self._at_eof = True
+                return
+
+    async def _read_boundary(self) -> None:
+        chunk = (await self._readline()).rstrip()
+        if chunk == self._boundary:
+            pass
+        elif chunk == self._boundary + b"--":
+            self._at_eof = True
+            epilogue = await self._readline()
+            next_line = await self._readline()
+
+            # the epilogue is expected and then either the end of input or the
+            # parent multipart boundary, if the parent boundary is found then
+            # it should be marked as unread and handed to the parent for
+            # processing
+            if next_line[:2] == b"--":
+                self._unread.append(next_line)
+            # otherwise the request is likely missing an epilogue and both
+            # lines should be passed to the parent for processing
+            # (this handles the old behavior gracefully)
+            else:
+                self._unread.extend([next_line, epilogue])
+        else:
+            raise ValueError(f"Invalid boundary {chunk!r}, expected {self._boundary!r}")
+
+    async def _read_headers(self) -> "CIMultiDictProxy[str]":
+        lines = [b""]
+        while True:
+            chunk = await self._content.readline()
+            chunk = chunk.strip()
+            lines.append(chunk)
+            if not chunk:
+                break
+        parser = HeadersParser()
+        headers, raw_headers = parser.parse_headers(lines)
+        return headers
+
+    async def _maybe_release_last_part(self) -> None:
+        """Ensures that the last read body part is read completely."""
+        if self._last_part is not None:
+            if not self._last_part.at_eof():
+                await self._last_part.release()
+            self._unread.extend(self._last_part._unread)
+            self._last_part = None
+
+
+_Part = Tuple[Payload, str, str]
+
+
+class MultipartWriter(Payload):
+    """Multipart body writer."""
+
+    def __init__(self, subtype: str = "mixed", boundary: Optional[str] = None) -> None:
+        boundary = boundary if boundary is not None else uuid.uuid4().hex
+        # The underlying Payload API demands a str (utf-8), not bytes,
+        # so we need to ensure we don't lose anything during conversion.
+        # As a result, require the boundary to be ASCII only.
+        # In both situations.
+
+        try:
+            self._boundary = boundary.encode("ascii")
+        except UnicodeEncodeError:
+            raise ValueError("boundary should contain ASCII only chars") from None
+        ctype = f"multipart/{subtype}; boundary={self._boundary_value}"
+
+        super().__init__(None, content_type=ctype)
+
+        self._parts: List[_Part] = []
+        self._is_form_data = subtype == "form-data"
+
+    def __enter__(self) -> "MultipartWriter":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        pass
+
+    def __iter__(self) -> Iterator[_Part]:
+        return iter(self._parts)
+
+    def __len__(self) -> int:
+        return len(self._parts)
+
+    def __bool__(self) -> bool:
+        return True
+
+    _valid_tchar_regex = re.compile(rb"\A[!#$%&'*+\-.^_`|~\w]+\Z")
+    _invalid_qdtext_char_regex = re.compile(rb"[\x00-\x08\x0A-\x1F\x7F]")
+
+    @property
+    def _boundary_value(self) -> str:
+        """Wrap boundary parameter value in quotes, if necessary.
+
+        Reads self.boundary and returns a unicode string.
+        """
+        # Refer to RFCs 7231, 7230, 5234.
+        #
+        # parameter      = token "=" ( token / quoted-string )
+        # token          = 1*tchar
+        # quoted-string  = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+        # qdtext         = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+        # obs-text       = %x80-FF
+        # quoted-pair    = "\" ( HTAB / SP / VCHAR / obs-text )
+        # tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+        #                  / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+        #                  / DIGIT / ALPHA
+        #                  ; any VCHAR, except delimiters
+        # VCHAR           = %x21-7E
+        value = self._boundary
+        if re.match(self._valid_tchar_regex, value):
+            return value.decode("ascii")  # cannot fail
+
+        if re.search(self._invalid_qdtext_char_regex, value):
+            raise ValueError("boundary value contains invalid characters")
+
+        # escape %x5C and %x22
+        quoted_value_content = value.replace(b"\\", b"\\\\")
+        quoted_value_content = quoted_value_content.replace(b'"', b'\\"')
+
+        return '"' + quoted_value_content.decode("ascii") + '"'
+
+    @property
+    def boundary(self) -> str:
+        return self._boundary.decode("ascii")
+
+    def append(self, obj: Any, headers: Optional[Mapping[str, str]] = None) -> Payload:
+        if headers is None:
+            headers = CIMultiDict()
+
+        if isinstance(obj, Payload):
+            obj.headers.update(headers)
+            return self.append_payload(obj)
+        else:
+            try:
+                payload = get_payload(obj, headers=headers)
+            except LookupError:
+                raise TypeError("Cannot create payload from %r" % obj)
+            else:
+                return self.append_payload(payload)
+
+    def append_payload(self, payload: Payload) -> Payload:
+        """Adds a new body part to multipart writer."""
+        encoding: Optional[str] = None
+        te_encoding: Optional[str] = None
+        if self._is_form_data:
+            # https://datatracker.ietf.org/doc/html/rfc7578#section-4.7
+            # https://datatracker.ietf.org/doc/html/rfc7578#section-4.8
+            assert CONTENT_DISPOSITION in payload.headers
+            assert "name=" in payload.headers[CONTENT_DISPOSITION]
+            assert (
+                not {CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TRANSFER_ENCODING}
+                & payload.headers.keys()
+            )
+        else:
+            # compression
+            encoding = payload.headers.get(CONTENT_ENCODING, "").lower()
+            if encoding and encoding not in ("deflate", "gzip", "identity"):
+                raise RuntimeError(f"unknown content encoding: {encoding}")
+            if encoding == "identity":
+                encoding = None
+
+            # te encoding
+            te_encoding = payload.headers.get(CONTENT_TRANSFER_ENCODING, "").lower()
+            if te_encoding not in ("", "base64", "quoted-printable", "binary"):
+                raise RuntimeError(f"unknown content transfer encoding: {te_encoding}")
+            if te_encoding == "binary":
+                te_encoding = None
+
+            # size
+            size = payload.size
+            if size is not None and not (encoding or te_encoding):
+                payload.headers[CONTENT_LENGTH] = str(size)
+
+        self._parts.append((payload, encoding, te_encoding))  # type: ignore[arg-type]
+        return payload
+
+    def append_json(
+        self, obj: Any, headers: Optional[Mapping[str, str]] = None
+    ) -> Payload:
+        """Helper to append JSON part."""
+        if headers is None:
+            headers = CIMultiDict()
+
+        return self.append_payload(JsonPayload(obj, headers=headers))
+
+    def append_form(
+        self,
+        obj: Union[Sequence[Tuple[str, str]], Mapping[str, str]],
+        headers: Optional[Mapping[str, str]] = None,
+    ) -> Payload:
+        """Helper to append form urlencoded part."""
+        assert isinstance(obj, (Sequence, Mapping))
+
+        if headers is None:
+            headers = CIMultiDict()
+
+        if isinstance(obj, Mapping):
+            obj = list(obj.items())
+        data = urlencode(obj, doseq=True)
+
+        return self.append_payload(
+            StringPayload(
+                data, headers=headers, content_type="application/x-www-form-urlencoded"
+            )
+        )
+
+    @property
+    def size(self) -> Optional[int]:
+        """Size of the payload."""
+        total = 0
+        for part, encoding, te_encoding in self._parts:
+            if encoding or te_encoding or part.size is None:
+                return None
+
+            total += int(
+                2
+                + len(self._boundary)
+                + 2
+                + part.size  # b'--'+self._boundary+b'\r\n'
+                + len(part._binary_headers)
+                + 2  # b'\r\n'
+            )
+
+        total += 2 + len(self._boundary) + 4  # b'--'+self._boundary+b'--\r\n'
+        return total
+
+    async def write(self, writer: Any, close_boundary: bool = True) -> None:
+        """Write body."""
+        for part, encoding, te_encoding in self._parts:
+            await writer.write(b"--" + self._boundary + b"\r\n")
+            await writer.write(part._binary_headers)
+
+            if encoding or te_encoding:
+                w = MultipartPayloadWriter(writer)
+                if encoding:
+                    w.enable_compression(encoding)
+                if te_encoding:
+                    w.enable_encoding(te_encoding)
+                await part.write(w)  # type: ignore[arg-type]
+                await w.write_eof()
+            else:
+                await part.write(writer)
+
+            await writer.write(b"\r\n")
+
+        if close_boundary:
+            await writer.write(b"--" + self._boundary + b"--\r\n")
+
+
+class MultipartPayloadWriter:
+    def __init__(self, writer: Any) -> None:
+        self._writer = writer
+        self._encoding: Optional[str] = None
+        self._compress: Optional[ZLibCompressor] = None
+        self._encoding_buffer: Optional[bytearray] = None
+
+    def enable_encoding(self, encoding: str) -> None:
+        if encoding == "base64":
+            self._encoding = encoding
+            self._encoding_buffer = bytearray()
+        elif encoding == "quoted-printable":
+            self._encoding = "quoted-printable"
+
+    def enable_compression(
+        self, encoding: str = "deflate", strategy: int = zlib.Z_DEFAULT_STRATEGY
+    ) -> None:
+        self._compress = ZLibCompressor(
+            encoding=encoding,
+            suppress_deflate_header=True,
+            strategy=strategy,
+        )
+
+    async def write_eof(self) -> None:
+        if self._compress is not None:
+            chunk = self._compress.flush()
+            if chunk:
+                self._compress = None
+                await self.write(chunk)
+
+        if self._encoding == "base64":
+            if self._encoding_buffer:
+                await self._writer.write(base64.b64encode(self._encoding_buffer))
+
+    async def write(self, chunk: bytes) -> None:
+        if self._compress is not None:
+            if chunk:
+                chunk = await self._compress.compress(chunk)
+                if not chunk:
+                    return
+
+        if self._encoding == "base64":
+            buf = self._encoding_buffer
+            assert buf is not None
+            buf.extend(chunk)
+
+            if buf:
+                div, mod = divmod(len(buf), 3)
+                enc_chunk, self._encoding_buffer = (buf[: div * 3], buf[div * 3 :])
+                if enc_chunk:
+                    b64chunk = base64.b64encode(enc_chunk)
+                    await self._writer.write(b64chunk)
+        elif self._encoding == "quoted-printable":
+            await self._writer.write(binascii.b2a_qp(chunk))
+        else:
+            await self._writer.write(chunk)

env-llmeval/lib/python3.10/site-packages/aiohttp/payload.py

@@ -0,0 +1,463 @@
+import asyncio
+import enum
+import io
+import json
+import mimetypes
+import os
+import warnings
+from abc import ABC, abstractmethod
+from itertools import chain
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    ByteString,
+    Dict,
+    Final,
+    Iterable,
+    Optional,
+    TextIO,
+    Tuple,
+    Type,
+    Union,
+)
+
+from multidict import CIMultiDict
+
+from . import hdrs
+from .abc import AbstractStreamWriter
+from .helpers import (
+    _SENTINEL,
+    content_disposition_header,
+    guess_filename,
+    parse_mimetype,
+    sentinel,
+)
+from .streams import StreamReader
+from .typedefs import JSONEncoder, _CIMultiDict
+
+__all__ = (
+    "PAYLOAD_REGISTRY",
+    "get_payload",
+    "payload_type",
+    "Payload",
+    "BytesPayload",
+    "StringPayload",
+    "IOBasePayload",
+    "BytesIOPayload",
+    "BufferedReaderPayload",
+    "TextIOPayload",
+    "StringIOPayload",
+    "JsonPayload",
+    "AsyncIterablePayload",
+)
+
+TOO_LARGE_BYTES_BODY: Final[int] = 2**20  # 1 MB
+
+if TYPE_CHECKING:
+    from typing import List
+
+
+class LookupError(Exception):
+    pass
+
+
+class Order(str, enum.Enum):
+    normal = "normal"
+    try_first = "try_first"
+    try_last = "try_last"
+
+
+def get_payload(data: Any, *args: Any, **kwargs: Any) -> "Payload":
+    return PAYLOAD_REGISTRY.get(data, *args, **kwargs)
+
+
+def register_payload(
+    factory: Type["Payload"], type: Any, *, order: Order = Order.normal
+) -> None:
+    PAYLOAD_REGISTRY.register(factory, type, order=order)
+
+
+class payload_type:
+    def __init__(self, type: Any, *, order: Order = Order.normal) -> None:
+        self.type = type
+        self.order = order
+
+    def __call__(self, factory: Type["Payload"]) -> Type["Payload"]:
+        register_payload(factory, self.type, order=self.order)
+        return factory
+
+
+PayloadType = Type["Payload"]
+_PayloadRegistryItem = Tuple[PayloadType, Any]
+
+
+class PayloadRegistry:
+    """Payload registry.
+
+    note: we need zope.interface for more efficient adapter search
+    """
+
+    def __init__(self) -> None:
+        self._first: List[_PayloadRegistryItem] = []
+        self._normal: List[_PayloadRegistryItem] = []
+        self._last: List[_PayloadRegistryItem] = []
+
+    def get(
+        self,
+        data: Any,
+        *args: Any,
+        _CHAIN: "Type[chain[_PayloadRegistryItem]]" = chain,
+        **kwargs: Any,
+    ) -> "Payload":
+        if isinstance(data, Payload):
+            return data
+        for factory, type in _CHAIN(self._first, self._normal, self._last):
+            if isinstance(data, type):
+                return factory(data, *args, **kwargs)
+
+        raise LookupError()
+
+    def register(
+        self, factory: PayloadType, type: Any, *, order: Order = Order.normal
+    ) -> None:
+        if order is Order.try_first:
+            self._first.append((factory, type))
+        elif order is Order.normal:
+            self._normal.append((factory, type))
+        elif order is Order.try_last:
+            self._last.append((factory, type))
+        else:
+            raise ValueError(f"Unsupported order {order!r}")
+
+
+class Payload(ABC):
+
+    _default_content_type: str = "application/octet-stream"
+    _size: Optional[int] = None
+
+    def __init__(
+        self,
+        value: Any,
+        headers: Optional[
+            Union[_CIMultiDict, Dict[str, str], Iterable[Tuple[str, str]]]
+        ] = None,
+        content_type: Union[str, None, _SENTINEL] = sentinel,
+        filename: Optional[str] = None,
+        encoding: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._encoding = encoding
+        self._filename = filename
+        self._headers: _CIMultiDict = CIMultiDict()
+        self._value = value
+        if content_type is not sentinel and content_type is not None:
+            self._headers[hdrs.CONTENT_TYPE] = content_type
+        elif self._filename is not None:
+            content_type = mimetypes.guess_type(self._filename)[0]
+            if content_type is None:
+                content_type = self._default_content_type
+            self._headers[hdrs.CONTENT_TYPE] = content_type
+        else:
+            self._headers[hdrs.CONTENT_TYPE] = self._default_content_type
+        self._headers.update(headers or {})
+
+    @property
+    def size(self) -> Optional[int]:
+        """Size of the payload."""
+        return self._size
+
+    @property
+    def filename(self) -> Optional[str]:
+        """Filename of the payload."""
+        return self._filename
+
+    @property
+    def headers(self) -> _CIMultiDict:
+        """Custom item headers"""
+        return self._headers
+
+    @property
+    def _binary_headers(self) -> bytes:
+        return (
+            "".join([k + ": " + v + "\r\n" for k, v in self.headers.items()]).encode(
+                "utf-8"
+            )
+            + b"\r\n"
+        )
+
+    @property
+    def encoding(self) -> Optional[str]:
+        """Payload encoding"""
+        return self._encoding
+
+    @property
+    def content_type(self) -> str:
+        """Content type"""
+        return self._headers[hdrs.CONTENT_TYPE]
+
+    def set_content_disposition(
+        self,
+        disptype: str,
+        quote_fields: bool = True,
+        _charset: str = "utf-8",
+        **params: Any,
+    ) -> None:
+        """Sets ``Content-Disposition`` header."""
+        self._headers[hdrs.CONTENT_DISPOSITION] = content_disposition_header(
+            disptype, quote_fields=quote_fields, _charset=_charset, **params
+        )
+
+    @abstractmethod
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        """Write payload.
+
+        writer is an AbstractStreamWriter instance:
+        """
+
+
+class BytesPayload(Payload):
+    def __init__(self, value: ByteString, *args: Any, **kwargs: Any) -> None:
+        if not isinstance(value, (bytes, bytearray, memoryview)):
+            raise TypeError(f"value argument must be byte-ish, not {type(value)!r}")
+
+        if "content_type" not in kwargs:
+            kwargs["content_type"] = "application/octet-stream"
+
+        super().__init__(value, *args, **kwargs)
+
+        if isinstance(value, memoryview):
+            self._size = value.nbytes
+        else:
+            self._size = len(value)
+
+        if self._size > TOO_LARGE_BYTES_BODY:
+            kwargs = {"source": self}
+            warnings.warn(
+                "Sending a large body directly with raw bytes might"
+                " lock the event loop. You should probably pass an "
+                "io.BytesIO object instead",
+                ResourceWarning,
+                **kwargs,
+            )
+
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        await writer.write(self._value)
+
+
+class StringPayload(BytesPayload):
+    def __init__(
+        self,
+        value: str,
+        *args: Any,
+        encoding: Optional[str] = None,
+        content_type: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+
+        if encoding is None:
+            if content_type is None:
+                real_encoding = "utf-8"
+                content_type = "text/plain; charset=utf-8"
+            else:
+                mimetype = parse_mimetype(content_type)
+                real_encoding = mimetype.parameters.get("charset", "utf-8")
+        else:
+            if content_type is None:
+                content_type = "text/plain; charset=%s" % encoding
+            real_encoding = encoding
+
+        super().__init__(
+            value.encode(real_encoding),
+            encoding=real_encoding,
+            content_type=content_type,
+            *args,
+            **kwargs,
+        )
+
+
+class StringIOPayload(StringPayload):
+    def __init__(self, value: IO[str], *args: Any, **kwargs: Any) -> None:
+        super().__init__(value.read(), *args, **kwargs)
+
+
+class IOBasePayload(Payload):
+    _value: IO[Any]
+
+    def __init__(
+        self, value: IO[Any], disposition: str = "attachment", *args: Any, **kwargs: Any
+    ) -> None:
+        if "filename" not in kwargs:
+            kwargs["filename"] = guess_filename(value)
+
+        super().__init__(value, *args, **kwargs)
+
+        if self._filename is not None and disposition is not None:
+            if hdrs.CONTENT_DISPOSITION not in self.headers:
+                self.set_content_disposition(disposition, filename=self._filename)
+
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        loop = asyncio.get_event_loop()
+        try:
+            chunk = await loop.run_in_executor(None, self._value.read, 2**16)
+            while chunk:
+                await writer.write(chunk)
+                chunk = await loop.run_in_executor(None, self._value.read, 2**16)
+        finally:
+            await loop.run_in_executor(None, self._value.close)
+
+
+class TextIOPayload(IOBasePayload):
+    _value: TextIO
+
+    def __init__(
+        self,
+        value: TextIO,
+        *args: Any,
+        encoding: Optional[str] = None,
+        content_type: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+
+        if encoding is None:
+            if content_type is None:
+                encoding = "utf-8"
+                content_type = "text/plain; charset=utf-8"
+            else:
+                mimetype = parse_mimetype(content_type)
+                encoding = mimetype.parameters.get("charset", "utf-8")
+        else:
+            if content_type is None:
+                content_type = "text/plain; charset=%s" % encoding
+
+        super().__init__(
+            value,
+            content_type=content_type,
+            encoding=encoding,
+            *args,
+            **kwargs,
+        )
+
+    @property
+    def size(self) -> Optional[int]:
+        try:
+            return os.fstat(self._value.fileno()).st_size - self._value.tell()
+        except OSError:
+            return None
+
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        loop = asyncio.get_event_loop()
+        try:
+            chunk = await loop.run_in_executor(None, self._value.read, 2**16)
+            while chunk:
+                data = (
+                    chunk.encode(encoding=self._encoding)
+                    if self._encoding
+                    else chunk.encode()
+                )
+                await writer.write(data)
+                chunk = await loop.run_in_executor(None, self._value.read, 2**16)
+        finally:
+            await loop.run_in_executor(None, self._value.close)
+
+
+class BytesIOPayload(IOBasePayload):
+    @property
+    def size(self) -> int:
+        position = self._value.tell()
+        end = self._value.seek(0, os.SEEK_END)
+        self._value.seek(position)
+        return end - position
+
+
+class BufferedReaderPayload(IOBasePayload):
+    @property
+    def size(self) -> Optional[int]:
+        try:
+            return os.fstat(self._value.fileno()).st_size - self._value.tell()
+        except OSError:
+            # data.fileno() is not supported, e.g.
+            # io.BufferedReader(io.BytesIO(b'data'))
+            return None
+
+
+class JsonPayload(BytesPayload):
+    def __init__(
+        self,
+        value: Any,
+        encoding: str = "utf-8",
+        content_type: str = "application/json",
+        dumps: JSONEncoder = json.dumps,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+
+        super().__init__(
+            dumps(value).encode(encoding),
+            content_type=content_type,
+            encoding=encoding,
+            *args,
+            **kwargs,
+        )
+
+
+if TYPE_CHECKING:
+    from typing import AsyncIterable, AsyncIterator
+
+    _AsyncIterator = AsyncIterator[bytes]
+    _AsyncIterable = AsyncIterable[bytes]
+else:
+    from collections.abc import AsyncIterable, AsyncIterator
+
+    _AsyncIterator = AsyncIterator
+    _AsyncIterable = AsyncIterable
+
+
+class AsyncIterablePayload(Payload):
+
+    _iter: Optional[_AsyncIterator] = None
+
+    def __init__(self, value: _AsyncIterable, *args: Any, **kwargs: Any) -> None:
+        if not isinstance(value, AsyncIterable):
+            raise TypeError(
+                "value argument must support "
+                "collections.abc.AsyncIterable interface, "
+                "got {!r}".format(type(value))
+            )
+
+        if "content_type" not in kwargs:
+            kwargs["content_type"] = "application/octet-stream"
+
+        super().__init__(value, *args, **kwargs)
+
+        self._iter = value.__aiter__()
+
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        if self._iter:
+            try:
+                # iter is not None check prevents rare cases
+                # when the case iterable is used twice
+                while True:
+                    chunk = await self._iter.__anext__()
+                    await writer.write(chunk)
+            except StopAsyncIteration:
+                self._iter = None
+
+
+class StreamReaderPayload(AsyncIterablePayload):
+    def __init__(self, value: StreamReader, *args: Any, **kwargs: Any) -> None:
+        super().__init__(value.iter_any(), *args, **kwargs)
+
+
+PAYLOAD_REGISTRY = PayloadRegistry()
+PAYLOAD_REGISTRY.register(BytesPayload, (bytes, bytearray, memoryview))
+PAYLOAD_REGISTRY.register(StringPayload, str)
+PAYLOAD_REGISTRY.register(StringIOPayload, io.StringIO)
+PAYLOAD_REGISTRY.register(TextIOPayload, io.TextIOBase)
+PAYLOAD_REGISTRY.register(BytesIOPayload, io.BytesIO)
+PAYLOAD_REGISTRY.register(BufferedReaderPayload, (io.BufferedReader, io.BufferedRandom))
+PAYLOAD_REGISTRY.register(IOBasePayload, io.IOBase)
+PAYLOAD_REGISTRY.register(StreamReaderPayload, StreamReader)
+# try_last for giving a chance to more specialized async interables like
+# multidict.BodyPartReaderPayload override the default
+PAYLOAD_REGISTRY.register(AsyncIterablePayload, AsyncIterable, order=Order.try_last)

env-llmeval/lib/python3.10/site-packages/aiohttp/payload_streamer.py

@@ -0,0 +1,75 @@
+"""
+Payload implementation for coroutines as data provider.
+
+As a simple case, you can upload data from file::
+
+   @aiohttp.streamer
+   async def file_sender(writer, file_name=None):
+      with open(file_name, 'rb') as f:
+          chunk = f.read(2**16)
+          while chunk:
+              await writer.write(chunk)
+
+              chunk = f.read(2**16)
+
+Then you can use `file_sender` like this:
+
+    async with session.post('http://httpbin.org/post',
+                            data=file_sender(file_name='huge_file')) as resp:
+        print(await resp.text())
+
+..note:: Coroutine must accept `writer` as first argument
+
+"""
+
+import types
+import warnings
+from typing import Any, Awaitable, Callable, Dict, Tuple
+
+from .abc import AbstractStreamWriter
+from .payload import Payload, payload_type
+
+__all__ = ("streamer",)
+
+
+class _stream_wrapper:
+    def __init__(
+        self,
+        coro: Callable[..., Awaitable[None]],
+        args: Tuple[Any, ...],
+        kwargs: Dict[str, Any],
+    ) -> None:
+        self.coro = types.coroutine(coro)
+        self.args = args
+        self.kwargs = kwargs
+
+    async def __call__(self, writer: AbstractStreamWriter) -> None:
+        await self.coro(writer, *self.args, **self.kwargs)
+
+
+class streamer:
+    def __init__(self, coro: Callable[..., Awaitable[None]]) -> None:
+        warnings.warn(
+            "@streamer is deprecated, use async generators instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.coro = coro
+
+    def __call__(self, *args: Any, **kwargs: Any) -> _stream_wrapper:
+        return _stream_wrapper(self.coro, args, kwargs)
+
+
+@payload_type(_stream_wrapper)
+class StreamWrapperPayload(Payload):
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        await self._value(writer)
+
+
+@payload_type(streamer)
+class StreamPayload(StreamWrapperPayload):
+    def __init__(self, value: Any, *args: Any, **kwargs: Any) -> None:
+        super().__init__(value(), *args, **kwargs)
+
+    async def write(self, writer: AbstractStreamWriter) -> None:
+        await self._value(writer)

env-llmeval/lib/python3.10/site-packages/aiohttp/py.typed

@@ -0,0 +1 @@
+Marker

env-llmeval/lib/python3.10/site-packages/aiohttp/pytest_plugin.py

@@ -0,0 +1,381 @@
+import asyncio
+import contextlib
+import warnings
+from typing import Any, Awaitable, Callable, Dict, Iterator, Optional, Type, Union
+
+import pytest
+
+from aiohttp.helpers import isasyncgenfunction
+from aiohttp.web import Application
+
+from .test_utils import (
+    BaseTestServer,
+    RawTestServer,
+    TestClient,
+    TestServer,
+    loop_context,
+    setup_test_loop,
+    teardown_test_loop,
+    unused_port as _unused_port,
+)
+
+try:
+    import uvloop
+except ImportError:  # pragma: no cover
+    uvloop = None  # type: ignore[assignment]
+
+AiohttpClient = Callable[[Union[Application, BaseTestServer]], Awaitable[TestClient]]
+AiohttpRawServer = Callable[[Application], Awaitable[RawTestServer]]
+AiohttpServer = Callable[[Application], Awaitable[TestServer]]
+
+
+def pytest_addoption(parser):  # type: ignore[no-untyped-def]
+    parser.addoption(
+        "--aiohttp-fast",
+        action="store_true",
+        default=False,
+        help="run tests faster by disabling extra checks",
+    )
+    parser.addoption(
+        "--aiohttp-loop",
+        action="store",
+        default="pyloop",
+        help="run tests with specific loop: pyloop, uvloop or all",
+    )
+    parser.addoption(
+        "--aiohttp-enable-loop-debug",
+        action="store_true",
+        default=False,
+        help="enable event loop debug mode",
+    )
+
+
+def pytest_fixture_setup(fixturedef):  # type: ignore[no-untyped-def]
+    """Set up pytest fixture.
+
+    Allow fixtures to be coroutines. Run coroutine fixtures in an event loop.
+    """
+    func = fixturedef.func
+
+    if isasyncgenfunction(func):
+        # async generator fixture
+        is_async_gen = True
+    elif asyncio.iscoroutinefunction(func):
+        # regular async fixture
+        is_async_gen = False
+    else:
+        # not an async fixture, nothing to do
+        return
+
+    strip_request = False
+    if "request" not in fixturedef.argnames:
+        fixturedef.argnames += ("request",)
+        strip_request = True
+
+    def wrapper(*args, **kwargs):  # type: ignore[no-untyped-def]
+        request = kwargs["request"]
+        if strip_request:
+            del kwargs["request"]
+
+        # if neither the fixture nor the test use the 'loop' fixture,
+        # 'getfixturevalue' will fail because the test is not parameterized
+        # (this can be removed someday if 'loop' is no longer parameterized)
+        if "loop" not in request.fixturenames:
+            raise Exception(
+                "Asynchronous fixtures must depend on the 'loop' fixture or "
+                "be used in tests depending from it."
+            )
+
+        _loop = request.getfixturevalue("loop")
+
+        if is_async_gen:
+            # for async generators, we need to advance the generator once,
+            # then advance it again in a finalizer
+            gen = func(*args, **kwargs)
+
+            def finalizer():  # type: ignore[no-untyped-def]
+                try:
+                    return _loop.run_until_complete(gen.__anext__())
+                except StopAsyncIteration:
+                    pass
+
+            request.addfinalizer(finalizer)
+            return _loop.run_until_complete(gen.__anext__())
+        else:
+            return _loop.run_until_complete(func(*args, **kwargs))
+
+    fixturedef.func = wrapper
+
+
+@pytest.fixture
+def fast(request):  # type: ignore[no-untyped-def]
+    """--fast config option"""
+    return request.config.getoption("--aiohttp-fast")
+
+
+@pytest.fixture
+def loop_debug(request):  # type: ignore[no-untyped-def]
+    """--enable-loop-debug config option"""
+    return request.config.getoption("--aiohttp-enable-loop-debug")
+
+
+@contextlib.contextmanager
+def _runtime_warning_context():  # type: ignore[no-untyped-def]
+    """Context manager which checks for RuntimeWarnings.
+
+    This exists specifically to
+    avoid "coroutine 'X' was never awaited" warnings being missed.
+
+    If RuntimeWarnings occur in the context a RuntimeError is raised.
+    """
+    with warnings.catch_warnings(record=True) as _warnings:
+        yield
+        rw = [
+            "{w.filename}:{w.lineno}:{w.message}".format(w=w)
+            for w in _warnings
+            if w.category == RuntimeWarning
+        ]
+        if rw:
+            raise RuntimeError(
+                "{} Runtime Warning{},\n{}".format(
+                    len(rw), "" if len(rw) == 1 else "s", "\n".join(rw)
+                )
+            )
+
+
+@contextlib.contextmanager
+def _passthrough_loop_context(loop, fast=False):  # type: ignore[no-untyped-def]
+    """Passthrough loop context.
+
+    Sets up and tears down a loop unless one is passed in via the loop
+    argument when it's passed straight through.
+    """
+    if loop:
+        # loop already exists, pass it straight through
+        yield loop
+    else:
+        # this shadows loop_context's standard behavior
+        loop = setup_test_loop()
+        yield loop
+        teardown_test_loop(loop, fast=fast)
+
+
+def pytest_pycollect_makeitem(collector, name, obj):  # type: ignore[no-untyped-def]
+    """Fix pytest collecting for coroutines."""
+    if collector.funcnamefilter(name) and asyncio.iscoroutinefunction(obj):
+        return list(collector._genfunctions(name, obj))
+
+
+def pytest_pyfunc_call(pyfuncitem):  # type: ignore[no-untyped-def]
+    """Run coroutines in an event loop instead of a normal function call."""
+    fast = pyfuncitem.config.getoption("--aiohttp-fast")
+    if asyncio.iscoroutinefunction(pyfuncitem.function):
+        existing_loop = pyfuncitem.funcargs.get(
+            "proactor_loop"
+        ) or pyfuncitem.funcargs.get("loop", None)
+        with _runtime_warning_context():
+            with _passthrough_loop_context(existing_loop, fast=fast) as _loop:
+                testargs = {
+                    arg: pyfuncitem.funcargs[arg]
+                    for arg in pyfuncitem._fixtureinfo.argnames
+                }
+                _loop.run_until_complete(pyfuncitem.obj(**testargs))
+
+        return True
+
+
+def pytest_generate_tests(metafunc):  # type: ignore[no-untyped-def]
+    if "loop_factory" not in metafunc.fixturenames:
+        return
+
+    loops = metafunc.config.option.aiohttp_loop
+    avail_factories: Dict[str, Type[asyncio.AbstractEventLoopPolicy]]
+    avail_factories = {"pyloop": asyncio.DefaultEventLoopPolicy}
+
+    if uvloop is not None:  # pragma: no cover
+        avail_factories["uvloop"] = uvloop.EventLoopPolicy
+
+    if loops == "all":
+        loops = "pyloop,uvloop?"
+
+    factories = {}  # type: ignore[var-annotated]
+    for name in loops.split(","):
+        required = not name.endswith("?")
+        name = name.strip(" ?")
+        if name not in avail_factories:  # pragma: no cover
+            if required:
+                raise ValueError(
+                    "Unknown loop '%s', available loops: %s"
+                    % (name, list(factories.keys()))
+                )
+            else:
+                continue
+        factories[name] = avail_factories[name]
+    metafunc.parametrize(
+        "loop_factory", list(factories.values()), ids=list(factories.keys())
+    )
+
+
+@pytest.fixture
+def loop(loop_factory, fast, loop_debug):  # type: ignore[no-untyped-def]
+    """Return an instance of the event loop."""
+    policy = loop_factory()
+    asyncio.set_event_loop_policy(policy)
+    with loop_context(fast=fast) as _loop:
+        if loop_debug:
+            _loop.set_debug(True)  # pragma: no cover
+        asyncio.set_event_loop(_loop)
+        yield _loop
+
+
+@pytest.fixture
+def proactor_loop():  # type: ignore[no-untyped-def]
+    policy = asyncio.WindowsProactorEventLoopPolicy()  # type: ignore[attr-defined]
+    asyncio.set_event_loop_policy(policy)
+
+    with loop_context(policy.new_event_loop) as _loop:
+        asyncio.set_event_loop(_loop)
+        yield _loop
+
+
+@pytest.fixture
+def unused_port(aiohttp_unused_port: Callable[[], int]) -> Callable[[], int]:
+    warnings.warn(
+        "Deprecated, use aiohttp_unused_port fixture instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return aiohttp_unused_port
+
+
+@pytest.fixture
+def aiohttp_unused_port() -> Callable[[], int]:
+    """Return a port that is unused on the current host."""
+    return _unused_port
+
+
+@pytest.fixture
+def aiohttp_server(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpServer]:
+    """Factory to create a TestServer instance, given an app.
+
+    aiohttp_server(app, **kwargs)
+    """
+    servers = []
+
+    async def go(app, *, port=None, **kwargs):  # type: ignore[no-untyped-def]
+        server = TestServer(app, port=port)
+        await server.start_server(loop=loop, **kwargs)
+        servers.append(server)
+        return server
+
+    yield go
+
+    async def finalize() -> None:
+        while servers:
+            await servers.pop().close()
+
+    loop.run_until_complete(finalize())
+
+
+@pytest.fixture
+def test_server(aiohttp_server):  # type: ignore[no-untyped-def]  # pragma: no cover
+    warnings.warn(
+        "Deprecated, use aiohttp_server fixture instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return aiohttp_server
+
+
+@pytest.fixture
+def aiohttp_raw_server(loop: asyncio.AbstractEventLoop) -> Iterator[AiohttpRawServer]:
+    """Factory to create a RawTestServer instance, given a web handler.
+
+    aiohttp_raw_server(handler, **kwargs)
+    """
+    servers = []
+
+    async def go(handler, *, port=None, **kwargs):  # type: ignore[no-untyped-def]
+        server = RawTestServer(handler, port=port)
+        await server.start_server(loop=loop, **kwargs)
+        servers.append(server)
+        return server
+
+    yield go
+
+    async def finalize() -> None:
+        while servers:
+            await servers.pop().close()
+
+    loop.run_until_complete(finalize())
+
+
+@pytest.fixture
+def raw_test_server(  # type: ignore[no-untyped-def]  # pragma: no cover
+    aiohttp_raw_server,
+):
+    warnings.warn(
+        "Deprecated, use aiohttp_raw_server fixture instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return aiohttp_raw_server
+
+
+@pytest.fixture
+def aiohttp_client(
+    loop: asyncio.AbstractEventLoop,
+) -> Iterator[AiohttpClient]:
+    """Factory to create a TestClient instance.
+
+    aiohttp_client(app, **kwargs)
+    aiohttp_client(server, **kwargs)
+    aiohttp_client(raw_server, **kwargs)
+    """
+    clients = []
+
+    async def go(
+        __param: Union[Application, BaseTestServer],
+        *args: Any,
+        server_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs: Any
+    ) -> TestClient:
+
+        if isinstance(__param, Callable) and not isinstance(  # type: ignore[arg-type]
+            __param, (Application, BaseTestServer)
+        ):
+            __param = __param(loop, *args, **kwargs)
+            kwargs = {}
+        else:
+            assert not args, "args should be empty"
+
+        if isinstance(__param, Application):
+            server_kwargs = server_kwargs or {}
+            server = TestServer(__param, loop=loop, **server_kwargs)
+            client = TestClient(server, loop=loop, **kwargs)
+        elif isinstance(__param, BaseTestServer):
+            client = TestClient(__param, loop=loop, **kwargs)
+        else:
+            raise ValueError("Unknown argument type: %r" % type(__param))
+
+        await client.start_server()
+        clients.append(client)
+        return client
+
+    yield go
+
+    async def finalize() -> None:
+        while clients:
+            await clients.pop().close()
+
+    loop.run_until_complete(finalize())
+
+
+@pytest.fixture
+def test_client(aiohttp_client):  # type: ignore[no-untyped-def]  # pragma: no cover
+    warnings.warn(
+        "Deprecated, use aiohttp_client fixture instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return aiohttp_client

env-llmeval/lib/python3.10/site-packages/aiohttp/resolver.py

@@ -0,0 +1,160 @@
+import asyncio
+import socket
+from typing import Any, Dict, List, Optional, Type, Union
+
+from .abc import AbstractResolver
+from .helpers import get_running_loop
+
+__all__ = ("ThreadedResolver", "AsyncResolver", "DefaultResolver")
+
+try:
+    import aiodns
+
+    # aiodns_default = hasattr(aiodns.DNSResolver, 'gethostbyname')
+except ImportError:  # pragma: no cover
+    aiodns = None
+
+aiodns_default = False
+
+
+class ThreadedResolver(AbstractResolver):
+    """Threaded resolver.
+
+    Uses an Executor for synchronous getaddrinfo() calls.
+    concurrent.futures.ThreadPoolExecutor is used by default.
+    """
+
+    def __init__(self, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
+        self._loop = get_running_loop(loop)
+
+    async def resolve(
+        self, hostname: str, port: int = 0, family: int = socket.AF_INET
+    ) -> List[Dict[str, Any]]:
+        infos = await self._loop.getaddrinfo(
+            hostname,
+            port,
+            type=socket.SOCK_STREAM,
+            family=family,
+            flags=socket.AI_ADDRCONFIG,
+        )
+
+        hosts = []
+        for family, _, proto, _, address in infos:
+            if family == socket.AF_INET6:
+                if len(address) < 3:
+                    # IPv6 is not supported by Python build,
+                    # or IPv6 is not enabled in the host
+                    continue
+                if address[3]:
+                    # This is essential for link-local IPv6 addresses.
+                    # LL IPv6 is a VERY rare case. Strictly speaking, we should use
+                    # getnameinfo() unconditionally, but performance makes sense.
+                    host, _port = socket.getnameinfo(
+                        address, socket.NI_NUMERICHOST | socket.NI_NUMERICSERV
+                    )
+                    port = int(_port)
+                else:
+                    host, port = address[:2]
+            else:  # IPv4
+                assert family == socket.AF_INET
+                host, port = address  # type: ignore[misc]
+            hosts.append(
+                {
+                    "hostname": hostname,
+                    "host": host,
+                    "port": port,
+                    "family": family,
+                    "proto": proto,
+                    "flags": socket.AI_NUMERICHOST | socket.AI_NUMERICSERV,
+                }
+            )
+
+        return hosts
+
+    async def close(self) -> None:
+        pass
+
+
+class AsyncResolver(AbstractResolver):
+    """Use the `aiodns` package to make asynchronous DNS lookups"""
+
+    def __init__(
+        self,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        *args: Any,
+        **kwargs: Any
+    ) -> None:
+        if aiodns is None:
+            raise RuntimeError("Resolver requires aiodns library")
+
+        self._loop = get_running_loop(loop)
+        self._resolver = aiodns.DNSResolver(*args, loop=loop, **kwargs)
+
+        if not hasattr(self._resolver, "gethostbyname"):
+            # aiodns 1.1 is not available, fallback to DNSResolver.query
+            self.resolve = self._resolve_with_query  # type: ignore
+
+    async def resolve(
+        self, host: str, port: int = 0, family: int = socket.AF_INET
+    ) -> List[Dict[str, Any]]:
+        try:
+            resp = await self._resolver.gethostbyname(host, family)
+        except aiodns.error.DNSError as exc:
+            msg = exc.args[1] if len(exc.args) >= 1 else "DNS lookup failed"
+            raise OSError(msg) from exc
+        hosts = []
+        for address in resp.addresses:
+            hosts.append(
+                {
+                    "hostname": host,
+                    "host": address,
+                    "port": port,
+                    "family": family,
+                    "proto": 0,
+                    "flags": socket.AI_NUMERICHOST | socket.AI_NUMERICSERV,
+                }
+            )
+
+        if not hosts:
+            raise OSError("DNS lookup failed")
+
+        return hosts
+
+    async def _resolve_with_query(
+        self, host: str, port: int = 0, family: int = socket.AF_INET
+    ) -> List[Dict[str, Any]]:
+        if family == socket.AF_INET6:
+            qtype = "AAAA"
+        else:
+            qtype = "A"
+
+        try:
+            resp = await self._resolver.query(host, qtype)
+        except aiodns.error.DNSError as exc:
+            msg = exc.args[1] if len(exc.args) >= 1 else "DNS lookup failed"
+            raise OSError(msg) from exc
+
+        hosts = []
+        for rr in resp:
+            hosts.append(
+                {
+                    "hostname": host,
+                    "host": rr.host,
+                    "port": port,
+                    "family": family,
+                    "proto": 0,
+                    "flags": socket.AI_NUMERICHOST,
+                }
+            )
+
+        if not hosts:
+            raise OSError("DNS lookup failed")
+
+        return hosts
+
+    async def close(self) -> None:
+        self._resolver.cancel()
+
+
+_DefaultType = Type[Union[AsyncResolver, ThreadedResolver]]
+DefaultResolver: _DefaultType = AsyncResolver if aiodns_default else ThreadedResolver

env-llmeval/lib/python3.10/site-packages/aiohttp/streams.py

@@ -0,0 +1,684 @@
+import asyncio
+import collections
+import warnings
+from typing import (
+    Awaitable,
+    Callable,
+    Deque,
+    Final,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+)
+
+from .base_protocol import BaseProtocol
+from .helpers import (
+    _EXC_SENTINEL,
+    BaseTimerContext,
+    TimerNoop,
+    set_exception,
+    set_result,
+)
+from .log import internal_logger
+
+__all__ = (
+    "EMPTY_PAYLOAD",
+    "EofStream",
+    "StreamReader",
+    "DataQueue",
+    "FlowControlDataQueue",
+)
+
+_T = TypeVar("_T")
+
+
+class EofStream(Exception):
+    """eof stream indication."""
+
+
+class AsyncStreamIterator(Generic[_T]):
+    def __init__(self, read_func: Callable[[], Awaitable[_T]]) -> None:
+        self.read_func = read_func
+
+    def __aiter__(self) -> "AsyncStreamIterator[_T]":
+        return self
+
+    async def __anext__(self) -> _T:
+        try:
+            rv = await self.read_func()
+        except EofStream:
+            raise StopAsyncIteration
+        if rv == b"":
+            raise StopAsyncIteration
+        return rv
+
+
+class ChunkTupleAsyncStreamIterator:
+    def __init__(self, stream: "StreamReader") -> None:
+        self._stream = stream
+
+    def __aiter__(self) -> "ChunkTupleAsyncStreamIterator":
+        return self
+
+    async def __anext__(self) -> Tuple[bytes, bool]:
+        rv = await self._stream.readchunk()
+        if rv == (b"", False):
+            raise StopAsyncIteration
+        return rv
+
+
+class AsyncStreamReaderMixin:
+    def __aiter__(self) -> AsyncStreamIterator[bytes]:
+        return AsyncStreamIterator(self.readline)  # type: ignore[attr-defined]
+
+    def iter_chunked(self, n: int) -> AsyncStreamIterator[bytes]:
+        """Returns an asynchronous iterator that yields chunks of size n."""
+        return AsyncStreamIterator(lambda: self.read(n))  # type: ignore[attr-defined]
+
+    def iter_any(self) -> AsyncStreamIterator[bytes]:
+        """Yield all available data as soon as it is received."""
+        return AsyncStreamIterator(self.readany)  # type: ignore[attr-defined]
+
+    def iter_chunks(self) -> ChunkTupleAsyncStreamIterator:
+        """Yield chunks of data as they are received by the server.
+
+        The yielded objects are tuples
+        of (bytes, bool) as returned by the StreamReader.readchunk method.
+        """
+        return ChunkTupleAsyncStreamIterator(self)  # type: ignore[arg-type]
+
+
+class StreamReader(AsyncStreamReaderMixin):
+    """An enhancement of asyncio.StreamReader.
+
+    Supports asynchronous iteration by line, chunk or as available::
+
+        async for line in reader:
+            ...
+        async for chunk in reader.iter_chunked(1024):
+            ...
+        async for slice in reader.iter_any():
+            ...
+
+    """
+
+    total_bytes = 0
+
+    def __init__(
+        self,
+        protocol: BaseProtocol,
+        limit: int,
+        *,
+        timer: Optional[BaseTimerContext] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        self._protocol = protocol
+        self._low_water = limit
+        self._high_water = limit * 2
+        if loop is None:
+            loop = asyncio.get_event_loop()
+        self._loop = loop
+        self._size = 0
+        self._cursor = 0
+        self._http_chunk_splits: Optional[List[int]] = None
+        self._buffer: Deque[bytes] = collections.deque()
+        self._buffer_offset = 0
+        self._eof = False
+        self._waiter: Optional[asyncio.Future[None]] = None
+        self._eof_waiter: Optional[asyncio.Future[None]] = None
+        self._exception: Optional[BaseException] = None
+        self._timer = TimerNoop() if timer is None else timer
+        self._eof_callbacks: List[Callable[[], None]] = []
+
+    def __repr__(self) -> str:
+        info = [self.__class__.__name__]
+        if self._size:
+            info.append("%d bytes" % self._size)
+        if self._eof:
+            info.append("eof")
+        if self._low_water != 2**16:  # default limit
+            info.append("low=%d high=%d" % (self._low_water, self._high_water))
+        if self._waiter:
+            info.append("w=%r" % self._waiter)
+        if self._exception:
+            info.append("e=%r" % self._exception)
+        return "<%s>" % " ".join(info)
+
+    def get_read_buffer_limits(self) -> Tuple[int, int]:
+        return (self._low_water, self._high_water)
+
+    def exception(self) -> Optional[BaseException]:
+        return self._exception
+
+    def set_exception(
+        self,
+        exc: BaseException,
+        exc_cause: BaseException = _EXC_SENTINEL,
+    ) -> None:
+        self._exception = exc
+        self._eof_callbacks.clear()
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_exception(waiter, exc, exc_cause)
+
+        waiter = self._eof_waiter
+        if waiter is not None:
+            self._eof_waiter = None
+            set_exception(waiter, exc, exc_cause)
+
+    def on_eof(self, callback: Callable[[], None]) -> None:
+        if self._eof:
+            try:
+                callback()
+            except Exception:
+                internal_logger.exception("Exception in eof callback")
+        else:
+            self._eof_callbacks.append(callback)
+
+    def feed_eof(self) -> None:
+        self._eof = True
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_result(waiter, None)
+
+        waiter = self._eof_waiter
+        if waiter is not None:
+            self._eof_waiter = None
+            set_result(waiter, None)
+
+        for cb in self._eof_callbacks:
+            try:
+                cb()
+            except Exception:
+                internal_logger.exception("Exception in eof callback")
+
+        self._eof_callbacks.clear()
+
+    def is_eof(self) -> bool:
+        """Return True if  'feed_eof' was called."""
+        return self._eof
+
+    def at_eof(self) -> bool:
+        """Return True if the buffer is empty and 'feed_eof' was called."""
+        return self._eof and not self._buffer
+
+    async def wait_eof(self) -> None:
+        if self._eof:
+            return
+
+        assert self._eof_waiter is None
+        self._eof_waiter = self._loop.create_future()
+        try:
+            await self._eof_waiter
+        finally:
+            self._eof_waiter = None
+
+    def unread_data(self, data: bytes) -> None:
+        """rollback reading some data from stream, inserting it to buffer head."""
+        warnings.warn(
+            "unread_data() is deprecated "
+            "and will be removed in future releases (#3260)",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if not data:
+            return
+
+        if self._buffer_offset:
+            self._buffer[0] = self._buffer[0][self._buffer_offset :]
+            self._buffer_offset = 0
+        self._size += len(data)
+        self._cursor -= len(data)
+        self._buffer.appendleft(data)
+        self._eof_counter = 0
+
+    # TODO: size is ignored, remove the param later
+    def feed_data(self, data: bytes, size: int = 0) -> None:
+        assert not self._eof, "feed_data after feed_eof"
+
+        if not data:
+            return
+
+        self._size += len(data)
+        self._buffer.append(data)
+        self.total_bytes += len(data)
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_result(waiter, None)
+
+        if self._size > self._high_water and not self._protocol._reading_paused:
+            self._protocol.pause_reading()
+
+    def begin_http_chunk_receiving(self) -> None:
+        if self._http_chunk_splits is None:
+            if self.total_bytes:
+                raise RuntimeError(
+                    "Called begin_http_chunk_receiving when" "some data was already fed"
+                )
+            self._http_chunk_splits = []
+
+    def end_http_chunk_receiving(self) -> None:
+        if self._http_chunk_splits is None:
+            raise RuntimeError(
+                "Called end_chunk_receiving without calling "
+                "begin_chunk_receiving first"
+            )
+
+        # self._http_chunk_splits contains logical byte offsets from start of
+        # the body transfer. Each offset is the offset of the end of a chunk.
+        # "Logical" means bytes, accessible for a user.
+        # If no chunks containing logical data were received, current position
+        # is difinitely zero.
+        pos = self._http_chunk_splits[-1] if self._http_chunk_splits else 0
+
+        if self.total_bytes == pos:
+            # We should not add empty chunks here. So we check for that.
+            # Note, when chunked + gzip is used, we can receive a chunk
+            # of compressed data, but that data may not be enough for gzip FSM
+            # to yield any uncompressed data. That's why current position may
+            # not change after receiving a chunk.
+            return
+
+        self._http_chunk_splits.append(self.total_bytes)
+
+        # wake up readchunk when end of http chunk received
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_result(waiter, None)
+
+    async def _wait(self, func_name: str) -> None:
+        # StreamReader uses a future to link the protocol feed_data() method
+        # to a read coroutine. Running two read coroutines at the same time
+        # would have an unexpected behaviour. It would not possible to know
+        # which coroutine would get the next data.
+        if self._waiter is not None:
+            raise RuntimeError(
+                "%s() called while another coroutine is "
+                "already waiting for incoming data" % func_name
+            )
+
+        waiter = self._waiter = self._loop.create_future()
+        try:
+            with self._timer:
+                await waiter
+        finally:
+            self._waiter = None
+
+    async def readline(self) -> bytes:
+        return await self.readuntil()
+
+    async def readuntil(self, separator: bytes = b"\n") -> bytes:
+        seplen = len(separator)
+        if seplen == 0:
+            raise ValueError("Separator should be at least one-byte string")
+
+        if self._exception is not None:
+            raise self._exception
+
+        chunk = b""
+        chunk_size = 0
+        not_enough = True
+
+        while not_enough:
+            while self._buffer and not_enough:
+                offset = self._buffer_offset
+                ichar = self._buffer[0].find(separator, offset) + 1
+                # Read from current offset to found separator or to the end.
+                data = self._read_nowait_chunk(
+                    ichar - offset + seplen - 1 if ichar else -1
+                )
+                chunk += data
+                chunk_size += len(data)
+                if ichar:
+                    not_enough = False
+
+                if chunk_size > self._high_water:
+                    raise ValueError("Chunk too big")
+
+            if self._eof:
+                break
+
+            if not_enough:
+                await self._wait("readuntil")
+
+        return chunk
+
+    async def read(self, n: int = -1) -> bytes:
+        if self._exception is not None:
+            raise self._exception
+
+        # migration problem; with DataQueue you have to catch
+        # EofStream exception, so common way is to run payload.read() inside
+        # infinite loop. what can cause real infinite loop with StreamReader
+        # lets keep this code one major release.
+        if __debug__:
+            if self._eof and not self._buffer:
+                self._eof_counter = getattr(self, "_eof_counter", 0) + 1
+                if self._eof_counter > 5:
+                    internal_logger.warning(
+                        "Multiple access to StreamReader in eof state, "
+                        "might be infinite loop.",
+                        stack_info=True,
+                    )
+
+        if not n:
+            return b""
+
+        if n < 0:
+            # This used to just loop creating a new waiter hoping to
+            # collect everything in self._buffer, but that would
+            # deadlock if the subprocess sends more than self.limit
+            # bytes.  So just call self.readany() until EOF.
+            blocks = []
+            while True:
+                block = await self.readany()
+                if not block:
+                    break
+                blocks.append(block)
+            return b"".join(blocks)
+
+        # TODO: should be `if` instead of `while`
+        # because waiter maybe triggered on chunk end,
+        # without feeding any data
+        while not self._buffer and not self._eof:
+            await self._wait("read")
+
+        return self._read_nowait(n)
+
+    async def readany(self) -> bytes:
+        if self._exception is not None:
+            raise self._exception
+
+        # TODO: should be `if` instead of `while`
+        # because waiter maybe triggered on chunk end,
+        # without feeding any data
+        while not self._buffer and not self._eof:
+            await self._wait("readany")
+
+        return self._read_nowait(-1)
+
+    async def readchunk(self) -> Tuple[bytes, bool]:
+        """Returns a tuple of (data, end_of_http_chunk).
+
+        When chunked transfer
+        encoding is used, end_of_http_chunk is a boolean indicating if the end
+        of the data corresponds to the end of a HTTP chunk , otherwise it is
+        always False.
+        """
+        while True:
+            if self._exception is not None:
+                raise self._exception
+
+            while self._http_chunk_splits:
+                pos = self._http_chunk_splits.pop(0)
+                if pos == self._cursor:
+                    return (b"", True)
+                if pos > self._cursor:
+                    return (self._read_nowait(pos - self._cursor), True)
+                internal_logger.warning(
+                    "Skipping HTTP chunk end due to data "
+                    "consumption beyond chunk boundary"
+                )
+
+            if self._buffer:
+                return (self._read_nowait_chunk(-1), False)
+                # return (self._read_nowait(-1), False)
+
+            if self._eof:
+                # Special case for signifying EOF.
+                # (b'', True) is not a final return value actually.
+                return (b"", False)
+
+            await self._wait("readchunk")
+
+    async def readexactly(self, n: int) -> bytes:
+        if self._exception is not None:
+            raise self._exception
+
+        blocks: List[bytes] = []
+        while n > 0:
+            block = await self.read(n)
+            if not block:
+                partial = b"".join(blocks)
+                raise asyncio.IncompleteReadError(partial, len(partial) + n)
+            blocks.append(block)
+            n -= len(block)
+
+        return b"".join(blocks)
+
+    def read_nowait(self, n: int = -1) -> bytes:
+        # default was changed to be consistent with .read(-1)
+        #
+        # I believe the most users don't know about the method and
+        # they are not affected.
+        if self._exception is not None:
+            raise self._exception
+
+        if self._waiter and not self._waiter.done():
+            raise RuntimeError(
+                "Called while some coroutine is waiting for incoming data."
+            )
+
+        return self._read_nowait(n)
+
+    def _read_nowait_chunk(self, n: int) -> bytes:
+        first_buffer = self._buffer[0]
+        offset = self._buffer_offset
+        if n != -1 and len(first_buffer) - offset > n:
+            data = first_buffer[offset : offset + n]
+            self._buffer_offset += n
+
+        elif offset:
+            self._buffer.popleft()
+            data = first_buffer[offset:]
+            self._buffer_offset = 0
+
+        else:
+            data = self._buffer.popleft()
+
+        self._size -= len(data)
+        self._cursor += len(data)
+
+        chunk_splits = self._http_chunk_splits
+        # Prevent memory leak: drop useless chunk splits
+        while chunk_splits and chunk_splits[0] < self._cursor:
+            chunk_splits.pop(0)
+
+        if self._size < self._low_water and self._protocol._reading_paused:
+            self._protocol.resume_reading()
+        return data
+
+    def _read_nowait(self, n: int) -> bytes:
+        """Read not more than n bytes, or whole buffer if n == -1"""
+        self._timer.assert_timeout()
+
+        chunks = []
+        while self._buffer:
+            chunk = self._read_nowait_chunk(n)
+            chunks.append(chunk)
+            if n != -1:
+                n -= len(chunk)
+                if n == 0:
+                    break
+
+        return b"".join(chunks) if chunks else b""
+
+
+class EmptyStreamReader(StreamReader):  # lgtm [py/missing-call-to-init]
+    def __init__(self) -> None:
+        self._read_eof_chunk = False
+
+    def __repr__(self) -> str:
+        return "<%s>" % self.__class__.__name__
+
+    def exception(self) -> Optional[BaseException]:
+        return None
+
+    def set_exception(
+        self,
+        exc: BaseException,
+        exc_cause: BaseException = _EXC_SENTINEL,
+    ) -> None:
+        pass
+
+    def on_eof(self, callback: Callable[[], None]) -> None:
+        try:
+            callback()
+        except Exception:
+            internal_logger.exception("Exception in eof callback")
+
+    def feed_eof(self) -> None:
+        pass
+
+    def is_eof(self) -> bool:
+        return True
+
+    def at_eof(self) -> bool:
+        return True
+
+    async def wait_eof(self) -> None:
+        return
+
+    def feed_data(self, data: bytes, n: int = 0) -> None:
+        pass
+
+    async def readline(self) -> bytes:
+        return b""
+
+    async def read(self, n: int = -1) -> bytes:
+        return b""
+
+    # TODO add async def readuntil
+
+    async def readany(self) -> bytes:
+        return b""
+
+    async def readchunk(self) -> Tuple[bytes, bool]:
+        if not self._read_eof_chunk:
+            self._read_eof_chunk = True
+            return (b"", False)
+
+        return (b"", True)
+
+    async def readexactly(self, n: int) -> bytes:
+        raise asyncio.IncompleteReadError(b"", n)
+
+    def read_nowait(self, n: int = -1) -> bytes:
+        return b""
+
+
+EMPTY_PAYLOAD: Final[StreamReader] = EmptyStreamReader()
+
+
+class DataQueue(Generic[_T]):
+    """DataQueue is a general-purpose blocking queue with one reader."""
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._eof = False
+        self._waiter: Optional[asyncio.Future[None]] = None
+        self._exception: Optional[BaseException] = None
+        self._size = 0
+        self._buffer: Deque[Tuple[_T, int]] = collections.deque()
+
+    def __len__(self) -> int:
+        return len(self._buffer)
+
+    def is_eof(self) -> bool:
+        return self._eof
+
+    def at_eof(self) -> bool:
+        return self._eof and not self._buffer
+
+    def exception(self) -> Optional[BaseException]:
+        return self._exception
+
+    def set_exception(
+        self,
+        exc: BaseException,
+        exc_cause: BaseException = _EXC_SENTINEL,
+    ) -> None:
+        self._eof = True
+        self._exception = exc
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_exception(waiter, exc, exc_cause)
+
+    def feed_data(self, data: _T, size: int = 0) -> None:
+        self._size += size
+        self._buffer.append((data, size))
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_result(waiter, None)
+
+    def feed_eof(self) -> None:
+        self._eof = True
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_result(waiter, None)
+
+    async def read(self) -> _T:
+        if not self._buffer and not self._eof:
+            assert not self._waiter
+            self._waiter = self._loop.create_future()
+            try:
+                await self._waiter
+            except (asyncio.CancelledError, asyncio.TimeoutError):
+                self._waiter = None
+                raise
+
+        if self._buffer:
+            data, size = self._buffer.popleft()
+            self._size -= size
+            return data
+        else:
+            if self._exception is not None:
+                raise self._exception
+            else:
+                raise EofStream
+
+    def __aiter__(self) -> AsyncStreamIterator[_T]:
+        return AsyncStreamIterator(self.read)
+
+
+class FlowControlDataQueue(DataQueue[_T]):
+    """FlowControlDataQueue resumes and pauses an underlying stream.
+
+    It is a destination for parsed data.
+    """
+
+    def __init__(
+        self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop
+    ) -> None:
+        super().__init__(loop=loop)
+
+        self._protocol = protocol
+        self._limit = limit * 2
+
+    def feed_data(self, data: _T, size: int = 0) -> None:
+        super().feed_data(data, size)
+
+        if self._size > self._limit and not self._protocol._reading_paused:
+            self._protocol.pause_reading()
+
+    async def read(self) -> _T:
+        try:
+            return await super().read()
+        finally:
+            if self._size < self._limit and self._protocol._reading_paused:
+                self._protocol.resume_reading()

env-llmeval/lib/python3.10/site-packages/aiohttp/tcp_helpers.py

@@ -0,0 +1,37 @@
+"""Helper methods to tune a TCP connection"""
+
+import asyncio
+import socket
+from contextlib import suppress
+from typing import Optional  # noqa
+
+__all__ = ("tcp_keepalive", "tcp_nodelay")
+
+
+if hasattr(socket, "SO_KEEPALIVE"):
+
+    def tcp_keepalive(transport: asyncio.Transport) -> None:
+        sock = transport.get_extra_info("socket")
+        if sock is not None:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+
+else:
+
+    def tcp_keepalive(transport: asyncio.Transport) -> None:  # pragma: no cover
+        pass
+
+
+def tcp_nodelay(transport: asyncio.Transport, value: bool) -> None:
+    sock = transport.get_extra_info("socket")
+
+    if sock is None:
+        return
+
+    if sock.family not in (socket.AF_INET, socket.AF_INET6):
+        return
+
+    value = bool(value)
+
+    # socket may be closed already, on windows OSError get raised
+    with suppress(OSError):
+        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, value)

env-llmeval/lib/python3.10/site-packages/aiohttp/test_utils.py

@@ -0,0 +1,682 @@
+"""Utilities shared by tests."""
+
+import asyncio
+import contextlib
+import gc
+import inspect
+import ipaddress
+import os
+import socket
+import sys
+import warnings
+from abc import ABC, abstractmethod
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterator,
+    List,
+    Optional,
+    Type,
+    Union,
+    cast,
+)
+from unittest import IsolatedAsyncioTestCase, mock
+
+from aiosignal import Signal
+from multidict import CIMultiDict, CIMultiDictProxy
+from yarl import URL
+
+import aiohttp
+from aiohttp.client import _RequestContextManager, _WSRequestContextManager
+
+from . import ClientSession, hdrs
+from .abc import AbstractCookieJar
+from .client_reqrep import ClientResponse
+from .client_ws import ClientWebSocketResponse
+from .helpers import sentinel
+from .http import HttpVersion, RawRequestMessage
+from .typedefs import StrOrURL
+from .web import (
+    Application,
+    AppRunner,
+    BaseRunner,
+    Request,
+    Server,
+    ServerRunner,
+    SockSite,
+    UrlMappingMatchInfo,
+)
+from .web_protocol import _RequestHandler
+
+if TYPE_CHECKING:
+    from ssl import SSLContext
+else:
+    SSLContext = None
+
+REUSE_ADDRESS = os.name == "posix" and sys.platform != "cygwin"
+
+
+def get_unused_port_socket(
+    host: str, family: socket.AddressFamily = socket.AF_INET
+) -> socket.socket:
+    return get_port_socket(host, 0, family)
+
+
+def get_port_socket(
+    host: str, port: int, family: socket.AddressFamily
+) -> socket.socket:
+    s = socket.socket(family, socket.SOCK_STREAM)
+    if REUSE_ADDRESS:
+        # Windows has different semantics for SO_REUSEADDR,
+        # so don't set it. Ref:
+        # https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind((host, port))
+    return s
+
+
+def unused_port() -> int:
+    """Return a port that is unused on the current host."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return cast(int, s.getsockname()[1])
+
+
+class BaseTestServer(ABC):
+    __test__ = False
+
+    def __init__(
+        self,
+        *,
+        scheme: Union[str, object] = sentinel,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        host: str = "127.0.0.1",
+        port: Optional[int] = None,
+        skip_url_asserts: bool = False,
+        socket_factory: Callable[
+            [str, int, socket.AddressFamily], socket.socket
+        ] = get_port_socket,
+        **kwargs: Any,
+    ) -> None:
+        self._loop = loop
+        self.runner: Optional[BaseRunner] = None
+        self._root: Optional[URL] = None
+        self.host = host
+        self.port = port
+        self._closed = False
+        self.scheme = scheme
+        self.skip_url_asserts = skip_url_asserts
+        self.socket_factory = socket_factory
+
+    async def start_server(
+        self, loop: Optional[asyncio.AbstractEventLoop] = None, **kwargs: Any
+    ) -> None:
+        if self.runner:
+            return
+        self._loop = loop
+        self._ssl = kwargs.pop("ssl", None)
+        self.runner = await self._make_runner(handler_cancellation=True, **kwargs)
+        await self.runner.setup()
+        if not self.port:
+            self.port = 0
+        try:
+            version = ipaddress.ip_address(self.host).version
+        except ValueError:
+            version = 4
+        family = socket.AF_INET6 if version == 6 else socket.AF_INET
+        _sock = self.socket_factory(self.host, self.port, family)
+        self.host, self.port = _sock.getsockname()[:2]
+        site = SockSite(self.runner, sock=_sock, ssl_context=self._ssl)
+        await site.start()
+        server = site._server
+        assert server is not None
+        sockets = server.sockets  # type: ignore[attr-defined]
+        assert sockets is not None
+        self.port = sockets[0].getsockname()[1]
+        if self.scheme is sentinel:
+            if self._ssl:
+                scheme = "https"
+            else:
+                scheme = "http"
+            self.scheme = scheme
+        self._root = URL(f"{self.scheme}://{self.host}:{self.port}")
+
+    @abstractmethod  # pragma: no cover
+    async def _make_runner(self, **kwargs: Any) -> BaseRunner:
+        pass
+
+    def make_url(self, path: StrOrURL) -> URL:
+        assert self._root is not None
+        url = URL(path)
+        if not self.skip_url_asserts:
+            assert not url.is_absolute()
+            return self._root.join(url)
+        else:
+            return URL(str(self._root) + str(path))
+
+    @property
+    def started(self) -> bool:
+        return self.runner is not None
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    @property
+    def handler(self) -> Server:
+        # for backward compatibility
+        # web.Server instance
+        runner = self.runner
+        assert runner is not None
+        assert runner.server is not None
+        return runner.server
+
+    async def close(self) -> None:
+        """Close all fixtures created by the test client.
+
+        After that point, the TestClient is no longer usable.
+
+        This is an idempotent function: running close multiple times
+        will not have any additional effects.
+
+        close is also run when the object is garbage collected, and on
+        exit when used as a context manager.
+
+        """
+        if self.started and not self.closed:
+            assert self.runner is not None
+            await self.runner.cleanup()
+            self._root = None
+            self.port = None
+            self._closed = True
+
+    def __enter__(self) -> None:
+        raise TypeError("Use async with instead")
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        # __exit__ should exist in pair with __enter__ but never executed
+        pass  # pragma: no cover
+
+    async def __aenter__(self) -> "BaseTestServer":
+        await self.start_server(loop=self._loop)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+
+class TestServer(BaseTestServer):
+    def __init__(
+        self,
+        app: Application,
+        *,
+        scheme: Union[str, object] = sentinel,
+        host: str = "127.0.0.1",
+        port: Optional[int] = None,
+        **kwargs: Any,
+    ):
+        self.app = app
+        super().__init__(scheme=scheme, host=host, port=port, **kwargs)
+
+    async def _make_runner(self, **kwargs: Any) -> BaseRunner:
+        return AppRunner(self.app, **kwargs)
+
+
+class RawTestServer(BaseTestServer):
+    def __init__(
+        self,
+        handler: _RequestHandler,
+        *,
+        scheme: Union[str, object] = sentinel,
+        host: str = "127.0.0.1",
+        port: Optional[int] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._handler = handler
+        super().__init__(scheme=scheme, host=host, port=port, **kwargs)
+
+    async def _make_runner(self, debug: bool = True, **kwargs: Any) -> ServerRunner:
+        srv = Server(self._handler, loop=self._loop, debug=debug, **kwargs)
+        return ServerRunner(srv, debug=debug, **kwargs)
+
+
+class TestClient:
+    """
+    A test client implementation.
+
+    To write functional tests for aiohttp based servers.
+
+    """
+
+    __test__ = False
+
+    def __init__(
+        self,
+        server: BaseTestServer,
+        *,
+        cookie_jar: Optional[AbstractCookieJar] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        **kwargs: Any,
+    ) -> None:
+        if not isinstance(server, BaseTestServer):
+            raise TypeError(
+                "server must be TestServer " "instance, found type: %r" % type(server)
+            )
+        self._server = server
+        self._loop = loop
+        if cookie_jar is None:
+            cookie_jar = aiohttp.CookieJar(unsafe=True, loop=loop)
+        self._session = ClientSession(loop=loop, cookie_jar=cookie_jar, **kwargs)
+        self._closed = False
+        self._responses: List[ClientResponse] = []
+        self._websockets: List[ClientWebSocketResponse] = []
+
+    async def start_server(self) -> None:
+        await self._server.start_server(loop=self._loop)
+
+    @property
+    def host(self) -> str:
+        return self._server.host
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._server.port
+
+    @property
+    def server(self) -> BaseTestServer:
+        return self._server
+
+    @property
+    def app(self) -> Optional[Application]:
+        return cast(Optional[Application], getattr(self._server, "app", None))
+
+    @property
+    def session(self) -> ClientSession:
+        """An internal aiohttp.ClientSession.
+
+        Unlike the methods on the TestClient, client session requests
+        do not automatically include the host in the url queried, and
+        will require an absolute path to the resource.
+
+        """
+        return self._session
+
+    def make_url(self, path: StrOrURL) -> URL:
+        return self._server.make_url(path)
+
+    async def _request(
+        self, method: str, path: StrOrURL, **kwargs: Any
+    ) -> ClientResponse:
+        resp = await self._session.request(method, self.make_url(path), **kwargs)
+        # save it to close later
+        self._responses.append(resp)
+        return resp
+
+    def request(
+        self, method: str, path: StrOrURL, **kwargs: Any
+    ) -> _RequestContextManager:
+        """Routes a request to tested http server.
+
+        The interface is identical to aiohttp.ClientSession.request,
+        except the loop kwarg is overridden by the instance used by the
+        test server.
+
+        """
+        return _RequestContextManager(self._request(method, path, **kwargs))
+
+    def get(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP GET request."""
+        return _RequestContextManager(self._request(hdrs.METH_GET, path, **kwargs))
+
+    def post(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP POST request."""
+        return _RequestContextManager(self._request(hdrs.METH_POST, path, **kwargs))
+
+    def options(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP OPTIONS request."""
+        return _RequestContextManager(self._request(hdrs.METH_OPTIONS, path, **kwargs))
+
+    def head(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP HEAD request."""
+        return _RequestContextManager(self._request(hdrs.METH_HEAD, path, **kwargs))
+
+    def put(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP PUT request."""
+        return _RequestContextManager(self._request(hdrs.METH_PUT, path, **kwargs))
+
+    def patch(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP PATCH request."""
+        return _RequestContextManager(self._request(hdrs.METH_PATCH, path, **kwargs))
+
+    def delete(self, path: StrOrURL, **kwargs: Any) -> _RequestContextManager:
+        """Perform an HTTP PATCH request."""
+        return _RequestContextManager(self._request(hdrs.METH_DELETE, path, **kwargs))
+
+    def ws_connect(self, path: StrOrURL, **kwargs: Any) -> _WSRequestContextManager:
+        """Initiate websocket connection.
+
+        The api corresponds to aiohttp.ClientSession.ws_connect.
+
+        """
+        return _WSRequestContextManager(self._ws_connect(path, **kwargs))
+
+    async def _ws_connect(
+        self, path: StrOrURL, **kwargs: Any
+    ) -> ClientWebSocketResponse:
+        ws = await self._session.ws_connect(self.make_url(path), **kwargs)
+        self._websockets.append(ws)
+        return ws
+
+    async def close(self) -> None:
+        """Close all fixtures created by the test client.
+
+        After that point, the TestClient is no longer usable.
+
+        This is an idempotent function: running close multiple times
+        will not have any additional effects.
+
+        close is also run on exit when used as a(n) (asynchronous)
+        context manager.
+
+        """
+        if not self._closed:
+            for resp in self._responses:
+                resp.close()
+            for ws in self._websockets:
+                await ws.close()
+            await self._session.close()
+            await self._server.close()
+            self._closed = True
+
+    def __enter__(self) -> None:
+        raise TypeError("Use async with instead")
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        # __exit__ should exist in pair with __enter__ but never executed
+        pass  # pragma: no cover
+
+    async def __aenter__(self) -> "TestClient":
+        await self.start_server()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+
+class AioHTTPTestCase(IsolatedAsyncioTestCase):
+    """A base class to allow for unittest web applications using aiohttp.
+
+    Provides the following:
+
+    * self.client (aiohttp.test_utils.TestClient): an aiohttp test client.
+    * self.loop (asyncio.BaseEventLoop): the event loop in which the
+        application and server are running.
+    * self.app (aiohttp.web.Application): the application returned by
+        self.get_application()
+
+    Note that the TestClient's methods are asynchronous: you have to
+    execute function on the test client using asynchronous methods.
+    """
+
+    async def get_application(self) -> Application:
+        """Get application.
+
+        This method should be overridden
+        to return the aiohttp.web.Application
+        object to test.
+        """
+        return self.get_app()
+
+    def get_app(self) -> Application:
+        """Obsolete method used to constructing web application.
+
+        Use .get_application() coroutine instead.
+        """
+        raise RuntimeError("Did you forget to define get_application()?")
+
+    async def asyncSetUp(self) -> None:
+        self.loop = asyncio.get_running_loop()
+        return await self.setUpAsync()
+
+    async def setUpAsync(self) -> None:
+        self.app = await self.get_application()
+        self.server = await self.get_server(self.app)
+        self.client = await self.get_client(self.server)
+
+        await self.client.start_server()
+
+    async def asyncTearDown(self) -> None:
+        return await self.tearDownAsync()
+
+    async def tearDownAsync(self) -> None:
+        await self.client.close()
+
+    async def get_server(self, app: Application) -> TestServer:
+        """Return a TestServer instance."""
+        return TestServer(app, loop=self.loop)
+
+    async def get_client(self, server: TestServer) -> TestClient:
+        """Return a TestClient instance."""
+        return TestClient(server, loop=self.loop)
+
+
+def unittest_run_loop(func: Any, *args: Any, **kwargs: Any) -> Any:
+    """
+    A decorator dedicated to use with asynchronous AioHTTPTestCase test methods.
+
+    In 3.8+, this does nothing.
+    """
+    warnings.warn(
+        "Decorator `@unittest_run_loop` is no longer needed in aiohttp 3.8+",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return func
+
+
+_LOOP_FACTORY = Callable[[], asyncio.AbstractEventLoop]
+
+
+@contextlib.contextmanager
+def loop_context(
+    loop_factory: _LOOP_FACTORY = asyncio.new_event_loop, fast: bool = False
+) -> Iterator[asyncio.AbstractEventLoop]:
+    """A contextmanager that creates an event_loop, for test purposes.
+
+    Handles the creation and cleanup of a test loop.
+    """
+    loop = setup_test_loop(loop_factory)
+    yield loop
+    teardown_test_loop(loop, fast=fast)
+
+
+def setup_test_loop(
+    loop_factory: _LOOP_FACTORY = asyncio.new_event_loop,
+) -> asyncio.AbstractEventLoop:
+    """Create and return an asyncio.BaseEventLoop instance.
+
+    The caller should also call teardown_test_loop,
+    once they are done with the loop.
+    """
+    loop = loop_factory()
+    asyncio.set_event_loop(loop)
+    return loop
+
+
+def teardown_test_loop(loop: asyncio.AbstractEventLoop, fast: bool = False) -> None:
+    """Teardown and cleanup an event_loop created by setup_test_loop."""
+    closed = loop.is_closed()
+    if not closed:
+        loop.call_soon(loop.stop)
+        loop.run_forever()
+        loop.close()
+
+    if not fast:
+        gc.collect()
+
+    asyncio.set_event_loop(None)
+
+
+def _create_app_mock() -> mock.MagicMock:
+    def get_dict(app: Any, key: str) -> Any:
+        return app.__app_dict[key]
+
+    def set_dict(app: Any, key: str, value: Any) -> None:
+        app.__app_dict[key] = value
+
+    app = mock.MagicMock(spec=Application)
+    app.__app_dict = {}
+    app.__getitem__ = get_dict
+    app.__setitem__ = set_dict
+
+    app._debug = False
+    app.on_response_prepare = Signal(app)
+    app.on_response_prepare.freeze()
+    return app
+
+
+def _create_transport(sslcontext: Optional[SSLContext] = None) -> mock.Mock:
+    transport = mock.Mock()
+
+    def get_extra_info(key: str) -> Optional[SSLContext]:
+        if key == "sslcontext":
+            return sslcontext
+        else:
+            return None
+
+    transport.get_extra_info.side_effect = get_extra_info
+    return transport
+
+
+def make_mocked_request(
+    method: str,
+    path: str,
+    headers: Any = None,
+    *,
+    match_info: Any = sentinel,
+    version: HttpVersion = HttpVersion(1, 1),
+    closing: bool = False,
+    app: Any = None,
+    writer: Any = sentinel,
+    protocol: Any = sentinel,
+    transport: Any = sentinel,
+    payload: Any = sentinel,
+    sslcontext: Optional[SSLContext] = None,
+    client_max_size: int = 1024**2,
+    loop: Any = ...,
+) -> Request:
+    """Creates mocked web.Request testing purposes.
+
+    Useful in unit tests, when spinning full web server is overkill or
+    specific conditions and errors are hard to trigger.
+    """
+    task = mock.Mock()
+    if loop is ...:
+        # no loop passed, try to get the current one if
+        # its is running as we need a real loop to create
+        # executor jobs to be able to do testing
+        # with a real executor
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = mock.Mock()
+            loop.create_future.return_value = ()
+
+    if version < HttpVersion(1, 1):
+        closing = True
+
+    if headers:
+        headers = CIMultiDictProxy(CIMultiDict(headers))
+        raw_hdrs = tuple(
+            (k.encode("utf-8"), v.encode("utf-8")) for k, v in headers.items()
+        )
+    else:
+        headers = CIMultiDictProxy(CIMultiDict())
+        raw_hdrs = ()
+
+    chunked = "chunked" in headers.get(hdrs.TRANSFER_ENCODING, "").lower()
+
+    message = RawRequestMessage(
+        method,
+        path,
+        version,
+        headers,
+        raw_hdrs,
+        closing,
+        None,
+        False,
+        chunked,
+        URL(path),
+    )
+    if app is None:
+        app = _create_app_mock()
+
+    if transport is sentinel:
+        transport = _create_transport(sslcontext)
+
+    if protocol is sentinel:
+        protocol = mock.Mock()
+        protocol.transport = transport
+
+    if writer is sentinel:
+        writer = mock.Mock()
+        writer.write_headers = make_mocked_coro(None)
+        writer.write = make_mocked_coro(None)
+        writer.write_eof = make_mocked_coro(None)
+        writer.drain = make_mocked_coro(None)
+        writer.transport = transport
+
+    protocol.transport = transport
+    protocol.writer = writer
+
+    if payload is sentinel:
+        payload = mock.Mock()
+
+    req = Request(
+        message, payload, protocol, writer, task, loop, client_max_size=client_max_size
+    )
+
+    match_info = UrlMappingMatchInfo(
+        {} if match_info is sentinel else match_info, mock.Mock()
+    )
+    match_info.add_app(app)
+    req._match_info = match_info
+
+    return req
+
+
+def make_mocked_coro(
+    return_value: Any = sentinel, raise_exception: Any = sentinel
+) -> Any:
+    """Creates a coroutine mock."""
+
+    async def mock_coro(*args: Any, **kwargs: Any) -> Any:
+        if raise_exception is not sentinel:
+            raise raise_exception
+        if not inspect.isawaitable(return_value):
+            return return_value
+        await return_value
+
+    return mock.Mock(wraps=mock_coro)