Add files using upload-large-folder tool

.gitattributes

@@ -279,3 +279,7 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5p.cp
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5i.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_conv.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/zstandard/_cffi.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_proxy.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchaudio/_torchaudio_ffmpeg.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5z.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/_qhull.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/_cparser.pxd

@@ -0,0 +1,190 @@
+from libc.stdint cimport (
+    int8_t,
+    int16_t,
+    int32_t,
+    int64_t,
+    uint8_t,
+    uint16_t,
+    uint32_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_CONNECTION_KEEP_ALIVE,
+        F_CONNECTION_CLOSE,
+        F_CONNECTION_UPGRADE,
+        F_CHUNKED,
+        F_UPGRADE,
+        F_CONTENT_LENGTH,
+        F_SKIPBODY,
+        F_TRAILING,
+        F_TRANSFER_ENCODING
+
+    enum llhttp_lenient_flags:
+        LENIENT_HEADERS,
+        LENIENT_CHUNKED_LENGTH
+
+    enum llhttp_type:
+        HTTP_REQUEST,
+        HTTP_RESPONSE,
+        HTTP_BOTH
+
+    enum llhttp_finish_t:
+        HTTP_FINISH_SAFE,
+        HTTP_FINISH_SAFE_WITH_CB,
+        HTTP_FINISH_UNSAFE
+
+    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)
+    llhttp_errno_t llhttp_finish(llhttp_t* parser)
+
+    int llhttp_message_needs_eof(const llhttp_t* parser)
+
+    int llhttp_should_keep_alive(const llhttp_t* parser)
+
+    void llhttp_pause(llhttp_t* parser)
+    void llhttp_resume(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)
+    void llhttp_set_error_reason(llhttp_t* parser, const char* reason)
+    const char* llhttp_get_error_pos(const llhttp_t* parser)
+    const char* llhttp_errno_name(llhttp_errno_t err)
+
+    const char* llhttp_method_name(llhttp_method_t method)
+
+    void llhttp_set_lenient_headers(llhttp_t* parser, int enabled)
+    void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled)

my_container_sandbox/workspace/anaconda3/lib/python3.8/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: ...

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/base_protocol.py

@@ -0,0 +1,87 @@
+import asyncio
+from typing import Optional, cast
+
+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 = loop  # type: asyncio.AbstractEventLoop
+        self._paused = False
+        self._drain_waiter = None  # type: Optional[asyncio.Future[None]]
+        self._connection_lost = False
+        self._reading_paused = False
+
+        self.transport = None  # type: Optional[asyncio.Transport]
+
+    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:
+        self._connection_lost = True
+        # 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:
+            waiter.set_exception(exc)
+
+    async def _drain_helper(self) -> None:
+        if self._connection_lost:
+            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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/client.py

@@ -0,0 +1,1302 @@
+"""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 (
+    Any,
+    Awaitable,
+    Callable,
+    Coroutine,
+    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 (
+    DEBUG,
+    PY_36,
+    BasicAuth,
+    TimeoutHandle,
+    ceil_timeout,
+    get_env_proxy_for_url,
+    get_running_loop,
+    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 Final, 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",
+)
+
+
+try:
+    from ssl import SSLContext
+except ImportError:  # pragma: no cover
+    SSLContext = object  # type: ignore[misc,assignment]
+
+
+@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
+
+    # 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")
+
+
+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",
+        ]
+    )
+
+    _source_traceback = 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: bool = False,
+        read_timeout: Union[float, object] = 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,
+    ) -> 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  # type: Optional[BaseConnector]
+        self._connector_owner = connector_owner
+        self._default_auth = auth
+        self._version = version
+        self._json_serialize = json_serialize
+        if timeout is sentinel:
+            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:
+            self._timeout = timeout  # type: ignore[assignment]
+            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
+
+        # Convert to list of tuples
+        if headers:
+            real_headers = CIMultiDict(headers)  # type: CIMultiDict[str]
+        else:
+            real_headers = CIMultiDict()
+        self._default_headers = real_headers  # type: CIMultiDict[str]
+        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()
+
+    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:
+            if PY_36:
+                kwargs = {"source": self}
+            else:
+                kwargs = {}
+            _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: Optional[bool] = None,
+        read_until_eof: bool = True,
+        proxy: Optional[StrOrURL] = None,
+        proxy_auth: Optional[BasicAuth] = None,
+        timeout: Union[ClientTimeout, object] = sentinel,
+        verify_ssl: Optional[bool] = None,
+        fingerprint: Optional[bytes] = None,
+        ssl_context: Optional[SSLContext] = None,
+        ssl: Optional[Union[SSLContext, bool, Fingerprint]] = None,
+        proxy_headers: Optional[LooseHeaders] = None,
+        trace_request_ctx: Optional[SimpleNamespace] = None,
+        read_bufsize: 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
+
+        # 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 = self._timeout  # type: ClientTimeout
+        else:
+            if not isinstance(timeout, ClientTimeout):
+                real_timeout = ClientTimeout(total=timeout)  # type: ignore[arg-type]
+            else:
+                real_timeout = timeout
+        # timeout is cumulative for all request operations
+        # (request, redirects, responses, data consuming)
+        tm = TimeoutHandle(self._loop, real_timeout.total)
+        handle = tm.start()
+
+        if read_bufsize is None:
+            read_bufsize = self._read_bufsize
+
+        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,
+                        proxy_headers=proxy_headers,
+                        traces=traces,
+                    )
+
+                    # connection timeout
+                    try:
+                        async with ceil_timeout(real_timeout.connect):
+                            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.upper() == "HEAD",
+                        read_until_eof=read_until_eof,
+                        auto_decompress=self._auto_decompress,
+                        read_timeout=real_timeout.sock_read,
+                        read_bufsize=read_bufsize,
+                    )
+
+                    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:
+                        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 = None
+                        resp.release()
+                        continue
+
+                    break
+
+            # check response status
+            if raise_for_status is None:
+                raise_for_status = self._raise_for_status
+            if 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] = None,
+        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: Union[SSLContext, bool, None, Fingerprint] = None,
+        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()  # type: CIMultiDict[str]
+        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
+
+        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(
+                conn_proto, 2 ** 16, loop=self._loop
+            )  # type: FlowControlDataQueue[WSMessage]
+            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()  # type: Set[str]
+            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) -> Union[object, 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, arg: BaseException) -> None:  # type: ignore[arg-type,override]
+        self._coro.throw(arg)
+
+    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()
+
+
+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 = None  # type: Optional[ClientResponse]
+        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,
+) -> _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,
+        ),
+        session,
+    )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/client_exceptions.py

@@ -0,0 +1,342 @@
+"""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:  # pragma: no cover
+    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):
+    """Connection error during reading response.
+
+    request_info: instance of RequestInfo
+    """
+
+    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
+        connection to proxy 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, None, 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, self.ssl if self.ssl is not None else "default", 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, self.ssl if self.ssl is not None else "default", 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)
+        )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/client_ws.py

@@ -0,0 +1,300 @@
+"""WebSocket client for asyncio."""
+
+import asyncio
+from typing import Any, Optional, cast
+
+import async_timeout
+
+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,
+)
+
+
+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 = None  # type: Optional[int]
+        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 = None  # type: Optional[asyncio.Future[bool]]
+        self._exception = None  # type: Optional[BaseException]
+        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
+            )
+
+    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
+            )
+
+    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._closed:
+            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._closing:
+                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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/cookiejar.py

@@ -0,0 +1,413 @@
+import asyncio
+import contextlib
+import datetime
+import os  # noqa
+import pathlib
+import pickle
+import re
+from collections import defaultdict
+from http.cookies import BaseCookie, Morsel, SimpleCookie
+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, next_whole_second
+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})")
+
+    MAX_TIME = datetime.datetime.max.replace(tzinfo=datetime.timezone.utc)
+
+    MAX_32BIT_TIME = datetime.datetime.utcfromtimestamp(2 ** 31 - 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(
+            SimpleCookie
+        )  # type: DefaultDict[str, SimpleCookie[str]]
+        self._host_only_cookies = set()  # type: Set[Tuple[str, str]]
+        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 = next_whole_second()
+        self._expirations = {}  # type: Dict[Tuple[str, str], datetime.datetime]
+        # #4515: datetime.max may not be representable on 32-bit platforms
+        self._max_time = self.MAX_TIME
+        try:
+            self._max_time.timestamp()
+        except OverflowError:
+            self._max_time = self.MAX_32BIT_TIME
+
+    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 = next_whole_second()
+            self._cookies.clear()
+            self._host_only_cookies.clear()
+            self._expirations.clear()
+            return
+
+        to_del = []
+        now = datetime.datetime.now(datetime.timezone.utc)
+        for domain, cookie in self._cookies.items():
+            for name, morsel in cookie.items():
+                key = (domain, name)
+                if (
+                    key in self._expirations and self._expirations[key] <= now
+                ) or predicate(morsel):
+                    to_del.append(key)
+
+        for domain, name in to_del:
+            key = (domain, name)
+            self._host_only_cookies.discard(key)
+            if key in self._expirations:
+                del self._expirations[(domain, name)]
+            self._cookies[domain].pop(name, None)
+
+        next_expiration = min(self._expirations.values(), default=self._max_time)
+        try:
+            self._next_expiration = next_expiration.replace(
+                microsecond=0
+            ) + datetime.timedelta(seconds=1)
+        except OverflowError:
+            self._next_expiration = 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: datetime.datetime, domain: str, name: str) -> None:
+        self._next_expiration = min(self._next_expiration, when)
+        self._expirations[(domain, 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()  # type: SimpleCookie[str]
+                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)
+                    try:
+                        max_age_expiration = datetime.datetime.now(
+                            datetime.timezone.utc
+                        ) + datetime.timedelta(seconds=delta_seconds)
+                    except OverflowError:
+                        max_age_expiration = self._max_time
+                    self._expire_cookie(max_age_expiration, domain, 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, name)
+                    else:
+                        cookie["expires"] = ""
+
+            self._cookies[domain][name] = cookie
+
+        self._do_expiration()
+
+    def filter_cookies(
+        self, request_url: URL = URL()
+    ) -> Union["BaseCookie[str]", "SimpleCookie[str]"]:
+        """Returns this jar's cookies filtered by their attributes."""
+        self._do_expiration()
+        request_url = URL(request_url)
+        filtered: Union["SimpleCookie[str]", "BaseCookie[str]"] = (
+            SimpleCookie() if self._quote_cookie else BaseCookie()
+        )
+        hostname = request_url.raw_host or ""
+        request_origin = URL()
+        with contextlib.suppress(ValueError):
+            request_origin = request_url.origin()
+
+        is_not_secure = (
+            request_url.scheme not in ("https", "wss")
+            and request_origin not in self._treat_as_secure_origin
+        )
+
+        for cookie in self:
+            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[datetime.datetime]:
+        """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 datetime.datetime(
+            year, month, day, hour, minute, second, tzinfo=datetime.timezone.utc
+        )
+
+
+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()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/helpers.py

@@ -0,0 +1,875 @@
+"""Various helper functions"""
+
+import asyncio
+import base64
+import binascii
+import cgi
+import datetime
+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.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,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+from urllib.parse import quote
+from urllib.request import getproxies, proxy_bypass
+
+import async_timeout
+import attr
+from multidict import MultiDict, MultiDictProxy
+from yarl import URL
+
+from . import hdrs
+from .log import client_logger, internal_logger
+from .typedefs import PathLike, Protocol  # noqa
+
+__all__ = ("BasicAuth", "ChainMapProxy", "ETag")
+
+IS_MACOS = platform.system() == "Darwin"
+IS_WINDOWS = platform.system() == "Windows"
+
+PY_36 = sys.version_info >= (3, 6)
+PY_37 = sys.version_info >= (3, 7)
+PY_38 = sys.version_info >= (3, 8)
+PY_310 = sys.version_info >= (3, 10)
+
+if sys.version_info < (3, 7):
+    import idna_ssl
+
+    idna_ssl.patch_match_hostname()
+
+    def all_tasks(
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> Set["asyncio.Task[Any]"]:
+        tasks = list(asyncio.Task.all_tasks(loop))
+        return {t for t in tasks if not t.done()}
+
+
+else:
+    all_tasks = asyncio.all_tasks
+
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+
+sentinel = object()  # type: Any
+NO_EXTENSIONS = bool(os.environ.get("AIOHTTP_NO_EXTENSIONS"))  # type: bool
+
+# N.B. sys.flags.dev_mode is available on Python 3.7+, use getattr
+# for compatibility with older versions
+DEBUG = getattr(sys.flags, "dev_mode", False) or (
+    not sys.flags.ignore_environment and bool(os.environ.get("PYTHONASYNCIODEBUG"))
+)  # type: bool
+
+
+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:
+        # we couldn't read the file (doesn't exist, permissions, etc.)
+        if netrc_env or netrc_path.is_file():
+            # 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 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:
+            auth_from_netrc = None
+            if proxy.host is not None:
+                auth_from_netrc = netrc_obj.authenticators(proxy.host)
+            if auth_from_netrc is not None:
+                # auth_from_netrc is a (`user`, `account`, `password`) tuple,
+                # `user` and `account` both can be username,
+                # if `user` is None, use `account`
+                *logins, password = auth_from_netrc
+                login = logins[0] if logins[0] else logins[-1]
+                auth = BasicAuth(cast(str, login), cast(str, password))
+        ret[proto] = ProxyInfo(proxy, auth)
+    return ret
+
+
+def current_task(
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> "Optional[asyncio.Task[Any]]":
+    if sys.version_info >= (3, 7):
+        return asyncio.current_task(loop=loop)
+    else:
+        return asyncio.Task.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()  # type: MultiDict[str]
+    for item in parts[1:]:
+        if not item:
+            continue
+        key, value = cast(
+            Tuple[str, str], item.split("=", 1) if "=" in item else (item, "")
+        )
+        params.add(key.lower().strip(), value.strip(' "'))
+
+    fulltype = parts[0].strip().lower()
+    if fulltype == "*":
+        fulltype = "*/*"
+
+    mtype, stype = (
+        cast(Tuple[str, str], fulltype.split("/", 1))
+        if "/" in fulltype
+        else (fulltype, "")
+    )
+    stype, suffix = (
+        cast(Tuple[str, str], stype.split("+", 1)) if "+" in stype else (stype, "")
+    )
+
+    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)
+
+
+def next_whole_second() -> datetime.datetime:
+    """Return current time rounded up to the next whole second."""
+    return datetime.datetime.now(datetime.timezone.utc).replace(
+        microsecond=0
+    ) + datetime.timedelta(seconds=0)
+
+
+_cached_current_datetime = None  # type: Optional[int]
+_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
+) -> Optional[asyncio.TimerHandle]:
+    if timeout is not None and timeout > 0:
+        when = loop.time() + timeout
+        if timeout >= 5:
+            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
+) -> Optional[asyncio.TimerHandle]:
+    if timeout is not None and timeout > 0:
+        when = loop.time() + timeout
+        if timeout > 5:
+            when = ceil(when)
+        return loop.call_at(when, cb)
+    return None
+
+
+class TimeoutHandle:
+    """Timeout handle"""
+
+    def __init__(
+        self, loop: asyncio.AbstractEventLoop, timeout: Optional[float]
+    ) -> None:
+        self._timeout = timeout
+        self._loop = loop
+        self._callbacks = (
+            []
+        )  # type: 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 >= 5:
+                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"]):
+    pass
+
+
+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 = []  # type: List[asyncio.Task[Any]]
+        self._cancelled = False
+
+    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]) -> 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 > 5:
+        when = ceil(when)
+    return async_timeout.timeout_at(when)
+
+
+class HeadersMixin:
+
+    ATTRS = frozenset(["_content_type", "_content_dict", "_stored_content_type"])
+
+    _content_type = None  # type: Optional[str]
+    _content_dict = None  # type: Optional[Dict[str, str]]
+    _stored_content_type = sentinel
+
+    def _parse_content_type(self, raw: 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:
+            self._content_type, self._content_dict = cgi.parse_header(raw)
+
+    @property
+    def content_type(self) -> str:
+        """The value of content part for Content-Type HTTP header."""
+        raw = self._headers.get(hdrs.CONTENT_TYPE)  # type: ignore[attr-defined]
+        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)  # type: ignore[attr-defined]
+        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(  # type: ignore[attr-defined]
+            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)
+
+
+def set_exception(fut: "asyncio.Future[_T]", exc: BaseException) -> None:
+    if not fut.done():
+        fut.set_exception(exc)
+
+
+class ChainMapProxy(Mapping[str, Any]):
+    __slots__ = ("_maps",)
+
+    def __init__(self, maps: Iterable[Mapping[str, Any]]) -> None:
+        self._maps = tuple(maps)
+
+    def __init_subclass__(cls) -> None:
+        raise TypeError(
+            "Inheritance class {} from ChainMapProxy "
+            "is forbidden".format(cls.__name__)
+        )
+
+    def __getitem__(self, key: str) -> Any:
+        for mapping in self._maps:
+            try:
+                return mapping[key]
+            except KeyError:
+                pass
+        raise KeyError(key)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self[key] if key in self else default
+
+    def __len__(self) -> int:
+        # reuses stored hash values if possible
+        return len(set().union(*self._maps))  # type: ignore[arg-type]
+
+    def __iter__(self) -> Iterator[str]:
+        d = {}  # type: Dict[str, 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"[!#-}\x80-\xff]+"
+_ETAGC_RE = re.compile(_ETAGC)
+_QUOTED_ETAG = fr'(W/)?"({_ETAGC})"'
+QUOTED_ETAG_RE = re.compile(_QUOTED_ETAG)
+LIST_QUOTED_ETAG_RE = re.compile(fr"({_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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/http.py

@@ -0,0 +1,72 @@
+import http.server
+import sys
+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 = "Python/{0[0]}.{0[1]} aiohttp/{1}".format(
+    sys.version_info, __version__
+)  # type: str
+
+RESPONSES = (
+    http.server.BaseHTTPRequestHandler.responses
+)  # type: Mapping[int, Tuple[str, str]]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/http_parser.py

@@ -0,0 +1,956 @@
+import abc
+import asyncio
+import collections
+import re
+import string
+import zlib
+from contextlib import suppress
+from enum import IntEnum
+from typing import (
+    Any,
+    Generic,
+    List,
+    NamedTuple,
+    Optional,
+    Pattern,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from multidict import CIMultiDict, CIMultiDictProxy, istr
+from yarl import URL
+
+from . import hdrs
+from .base_protocol import BaseProtocol
+from .helpers import NO_EXTENSIONS, BaseTimerContext
+from .http_exceptions import (
+    BadHttpMessage,
+    BadStatusLine,
+    ContentEncodingError,
+    ContentLengthError,
+    InvalidHeader,
+    LineTooLong,
+    TransferEncodingError,
+)
+from .http_writer import HttpVersion, HttpVersion10
+from .log import internal_logger
+from .streams import EMPTY_PAYLOAD, StreamReader
+from .typedefs import Final, RawHeaders
+
+try:
+    import brotli
+
+    HAS_BROTLI = True
+except ImportError:  # pragma: no cover
+    HAS_BROTLI = False
+
+
+__all__ = (
+    "HeadersParser",
+    "HttpParser",
+    "HttpRequestParser",
+    "HttpResponseParser",
+    "RawRequestMessage",
+    "RawResponseMessage",
+)
+
+ASCIISET: Final[Set[str]] = set(string.printable)
+
+# See https://tools.ietf.org/html/rfc7230#section-3.1.1
+# and https://tools.ietf.org/html/rfc7230#appendix-B
+#
+#     method = token
+#     tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
+#             "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
+#     token = 1*tchar
+METHRE: Final[Pattern[str]] = re.compile(r"[!#$%&'*+\-.^_`|~0-9A-Za-z]+")
+VERSRE: Final[Pattern[str]] = re.compile(r"HTTP/(\d+).(\d+)")
+HDRRE: Final[Pattern[bytes]] = re.compile(rb"[\x00-\x1F\x7F()<>@,;:\[\]={} \t\\\\\"]")
+
+
+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
+
+
+RawResponseMessage = collections.namedtuple(
+    "RawResponseMessage",
+    [
+        "version",
+        "code",
+        "reason",
+        "headers",
+        "raw_headers",
+        "should_close",
+        "compression",
+        "upgrade",
+        "chunked",
+    ],
+)
+
+
+_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,
+    ) -> None:
+        self.max_line_size = max_line_size
+        self.max_headers = max_headers
+        self.max_field_size = max_field_size
+
+    def parse_headers(
+        self, lines: List[bytes]
+    ) -> Tuple["CIMultiDictProxy[str]", RawHeaders]:
+        headers = CIMultiDict()  # type: CIMultiDict[str]
+        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
+
+            bname = bname.strip(b" \t")
+            bvalue = bvalue.lstrip()
+            if HDRRE.search(bname):
+                raise InvalidHeader(bname)
+            if len(bname) > self.max_field_size:
+                raise LineTooLong(
+                    "request header name {}".format(
+                        bname.decode("utf8", "xmlcharrefreplace")
+                    ),
+                    str(self.max_field_size),
+                    str(len(bname)),
+                )
+
+            header_length = len(bvalue)
+
+            # next line
+            lines_idx += 1
+            line = lines[lines_idx]
+
+            # consume continuation lines
+            continuation = line and line[0] in (32, 9)  # (' ', '\t')
+
+            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", "xmlcharrefreplace")
+                            ),
+                            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", "xmlcharrefreplace")
+                        ),
+                        str(self.max_field_size),
+                        str(header_length),
+                    )
+
+            bvalue = bvalue.strip()
+            name = bname.decode("utf-8", "surrogateescape")
+            value = bvalue.decode("utf-8", "surrogateescape")
+
+            headers.add(name, value)
+            raw_headers.append((bname, bvalue))
+
+        return (CIMultiDictProxy(headers), tuple(raw_headers))
+
+
+class HttpParser(abc.ABC, Generic[_MsgT]):
+    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 = []  # type: List[bytes]
+        self._tail = b""
+        self._upgraded = False
+        self._payload = None
+        self._payload_parser = None  # type: Optional[HttpPayloadParser]
+        self._auto_decompress = auto_decompress
+        self._limit = limit
+        self._headers_parser = HeadersParser(max_line_size, max_headers, max_field_size)
+
+    @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: bytes = 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 + 2
+                    continue
+
+                if pos >= start_pos:
+                    # line found
+                    self._lines.append(data[start_pos:pos])
+                    start_pos = pos + 2
+
+                    # \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
+
+                            try:
+                                length = int(length_hdr)
+                            except ValueError:
+                                raise InvalidHeader(CONTENT_LENGTH)
+
+                            if length < 0:
+                                raise InvalidHeader(CONTENT_LENGTH)
+
+                            return length
+
+                        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
+
+                        method = getattr(msg, "method", self.method)
+
+                        assert self.protocol is not None
+                        # calculate payload
+                        if (
+                            (length is not None and length > 0)
+                            or msg.chunked
+                            and not msg.upgrade
+                        ):
+                            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,
+                            )
+                            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,
+                            )
+                        else:
+                            if (
+                                getattr(msg, "code", 100) >= 199
+                                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,
+                                )
+                                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:])
+                except BaseException as exc:
+                    if self.payload_exception is not None:
+                        self._payload_parser.payload.set_exception(
+                            self.payload_exception(str(exc))
+                        )
+                    else:
+                        self._payload_parser.payload.set_exception(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
+
+        # 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
+            elif v == "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(
+                    "Content-Length can't be present with Transfer-Encoding",
+                )
+
+        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(None, 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))
+            )
+
+        path_part, _hash_separator, url_fragment = path.partition("#")
+        path_part, _question_mark_separator, qs_part = path_part.partition("?")
+
+        # method
+        if not METHRE.match(method):
+            raise BadStatusLine(method)
+
+        # version
+        try:
+            if version.startswith("HTTP/"):
+                n1, n2 = version[5:].split(".", 1)
+                version_o = HttpVersion(int(n1), int(n2))
+            else:
+                raise BadStatusLine(version)
+        except Exception:
+            raise BadStatusLine(version)
+
+        # 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,
+            # 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.build(
+                path=path_part,
+                query_string=qs_part,
+                fragment=url_fragment,
+                encoded=True,
+            ),
+        )
+
+
+class HttpResponseParser(HttpParser[RawResponseMessage]):
+    """Read response status line and headers.
+
+    BadStatusLine could be raised in case of any errors in status line.
+    Returns RawResponseMessage.
+    """
+
+    def parse_message(self, lines: List[bytes]) -> RawResponseMessage:
+        line = lines[0].decode("utf-8", "surrogateescape")
+        try:
+            version, status = line.split(None, 1)
+        except ValueError:
+            raise BadStatusLine(line) from None
+
+        try:
+            status, reason = status.split(None, 1)
+        except ValueError:
+            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.match(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 number
+        try:
+            status_i = int(status)
+        except ValueError:
+            raise BadStatusLine(line) from None
+
+        if status_i > 999:
+            raise BadStatusLine(line)
+
+        # read headers
+        (
+            headers,
+            raw_headers,
+            close,
+            compression,
+            upgrade,
+            chunked,
+        ) = self.parse_headers(lines)
+
+        if close is None:
+            close = version_o <= HttpVersion10
+
+        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,
+    ) -> 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.done = False
+
+        # payload decompression wrapper
+        if response_with_body and compression and self._auto_decompress:
+            real_payload = DeflateBuffer(
+                payload, compression
+            )  # type: Union[StreamReader, DeflateBuffer]
+        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: bytes = 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]
+
+                        try:
+                            size = int(bytes(size_b), 16)
+                        except ValueError:
+                            exc = TransferEncodingError(
+                                chunk[:pos].decode("ascii", "surrogateescape")
+                            )
+                            self.payload.set_exception(exc)
+                            raise exc from None
+
+                        chunk = chunk[pos + 2 :]
+                        if size == 0:  # eof marker
+                            self._chunk = ChunkState.PARSE_MAYBE_TRAILERS
+                        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:]
+                        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[:2] == SEP:
+                        chunk = chunk[2:]
+                        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 skiped until \r\n\r\n
+                if self._chunk == ChunkState.PARSE_MAYBE_TRAILERS:
+                    head = chunk[:2]
+                    if head == SEP:
+                        # end of stream
+                        self.payload.feed_eof()
+                        return True, chunk[2:]
+                    # 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 + 2 :]
+                        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
+
+        if encoding == "br":
+            if not HAS_BROTLI:  # pragma: no cover
+                raise ContentEncodingError(
+                    "Can not decode content-encoding: brotli (br). "
+                    "Please install `Brotli`"
+                )
+
+            class BrotliDecoder:
+                # 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:
+                    self._obj = brotli.Decompressor()
+
+                def decompress(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""
+
+            self.decompressor = BrotliDecoder()
+        else:
+            zlib_mode = 16 + zlib.MAX_WBITS if encoding == "gzip" else zlib.MAX_WBITS
+            self.decompressor = zlib.decompressobj(wbits=zlib_mode)
+
+    def set_exception(self, exc: BaseException) -> None:
+        self.out.set_exception(exc)
+
+    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 = zlib.decompressobj(wbits=-zlib.MAX_WBITS)
+
+        try:
+            chunk = self.decompressor.decompress(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,no-redef]
+            HttpRequestParser,
+            HttpResponseParser,
+            RawRequestMessage,
+            RawResponseMessage,
+        )
+
+        HttpRequestParserC = HttpRequestParser
+        HttpResponseParserC = HttpResponseParser
+        RawRequestMessageC = RawRequestMessage
+        RawResponseMessageC = RawResponseMessage
+except ImportError:  # pragma: no cover
+    pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/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 = None  # type: Optional[BaseException]
+        self._event = asyncio.Event()
+        self._waiters = collections.deque()  # type: Deque[asyncio.Future[Any]]
+
+    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()

my_container_sandbox/workspace/anaconda3/lib/python3.8/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")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/payload.py

@@ -0,0 +1,465 @@
+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,
+    Iterable,
+    Optional,
+    TextIO,
+    Tuple,
+    Type,
+    Union,
+)
+
+from multidict import CIMultiDict
+
+from . import hdrs
+from .abc import AbstractStreamWriter
+from .helpers import (
+    PY_36,
+    content_disposition_header,
+    guess_filename,
+    parse_mimetype,
+    sentinel,
+)
+from .streams import StreamReader
+from .typedefs import Final, 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:  # pragma: no cover
+    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 = []  # type: List[_PayloadRegistryItem]
+        self._normal = []  # type: List[_PayloadRegistryItem]
+        self._last = []  # type: 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 = "application/octet-stream"  # type: str
+    _size = None  # type: Optional[int]
+
+    def __init__(
+        self,
+        value: Any,
+        headers: Optional[
+            Union[_CIMultiDict, Dict[str, str], Iterable[Tuple[str, str]]]
+        ] = None,
+        content_type: Optional[str] = sentinel,
+        filename: Optional[str] = None,
+        encoding: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._encoding = encoding
+        self._filename = filename
+        self._headers = CIMultiDict()  # type: _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:
+            if PY_36:
+                kwargs = {"source": self}
+            else:
+                kwargs = {}
+            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:  # pragma: no cover
+    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 = None  # type: Optional[_AsyncIterator]
+
+    def __init__(self, value: _AsyncIterable, *args: Any, **kwargs: Any) -> None:
+        if not isinstance(value, AsyncIterable):
+            raise TypeError(
+                "value argument must support "
+                "collections.abc.AsyncIterablebe 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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/py.typed

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/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]:  # type: ignore[misc]
+                    # 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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/streams.py

@@ -0,0 +1,660 @@
+import asyncio
+import collections
+import warnings
+from typing import Awaitable, Callable, Deque, Generic, List, Optional, Tuple, TypeVar
+
+from .base_protocol import BaseProtocol
+from .helpers import BaseTimerContext, set_exception, set_result
+from .log import internal_logger
+from .typedefs import Final
+
+__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.
+
+        Python-3.5 available for Python 3.5+ only
+        """
+        return AsyncStreamIterator(
+            lambda: self.read(n)  # type: ignore[attr-defined,no-any-return]
+        )
+
+    def iter_any(self) -> AsyncStreamIterator[bytes]:
+        """Yield all available data as soon as it is received.
+
+        Python-3.5 available for Python 3.5+ only
+        """
+        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.
+
+        Python-3.5 available for Python 3.5+ only
+        """
+        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 = None  # type: Optional[List[int]]
+        self._buffer = collections.deque()  # type: Deque[bytes]
+        self._buffer_offset = 0
+        self._eof = False
+        self._waiter = None  # type: Optional[asyncio.Future[None]]
+        self._eof_waiter = None  # type: Optional[asyncio.Future[None]]
+        self._exception = None  # type: Optional[BaseException]
+        self._timer = timer
+        self._eof_callbacks = []  # type: 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) -> None:
+        self._exception = exc
+        self._eof_callbacks.clear()
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_exception(waiter, exc)
+
+        waiter = self._eof_waiter
+        if waiter is not None:
+            self._eof_waiter = None
+            set_exception(waiter, exc)
+
+    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 containig 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:
+            if self._timer:
+                with self._timer:
+                    await waiter
+            else:
+                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 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 = []  # type: 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"""
+        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:
+        pass
+
+    def exception(self) -> Optional[BaseException]:
+        return None
+
+    def set_exception(self, exc: BaseException) -> 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]:
+        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 = None  # type: Optional[asyncio.Future[None]]
+        self._exception = None  # type: Optional[BaseException]
+        self._size = 0
+        self._buffer = collections.deque()  # type: Deque[Tuple[_T, int]]
+
+    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) -> None:
+        self._eof = True
+        self._exception = exc
+
+        waiter = self._waiter
+        if waiter is not None:
+            self._waiter = None
+            set_exception(waiter, exc)
+
+    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()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/tracing.py

@@ -0,0 +1,472 @@
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Awaitable, Optional, Type, TypeVar
+
+import attr
+from aiosignal import Signal
+from multidict import CIMultiDict
+from yarl import URL
+
+from .client_reqrep import ClientResponse
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import ClientSession
+    from .typedefs import Protocol
+
+    _ParamT_contra = TypeVar("_ParamT_contra", contravariant=True)
+
+    class _SignalCallback(Protocol[_ParamT_contra]):
+        def __call__(
+            self,
+            __client_session: ClientSession,
+            __trace_config_ctx: SimpleNamespace,
+            __params: _ParamT_contra,
+        ) -> Awaitable[None]:
+            ...
+
+
+__all__ = (
+    "TraceConfig",
+    "TraceRequestStartParams",
+    "TraceRequestEndParams",
+    "TraceRequestExceptionParams",
+    "TraceConnectionQueuedStartParams",
+    "TraceConnectionQueuedEndParams",
+    "TraceConnectionCreateStartParams",
+    "TraceConnectionCreateEndParams",
+    "TraceConnectionReuseconnParams",
+    "TraceDnsResolveHostStartParams",
+    "TraceDnsResolveHostEndParams",
+    "TraceDnsCacheHitParams",
+    "TraceDnsCacheMissParams",
+    "TraceRequestRedirectParams",
+    "TraceRequestChunkSentParams",
+    "TraceResponseChunkReceivedParams",
+    "TraceRequestHeadersSentParams",
+)
+
+
+class TraceConfig:
+    """First-class used to trace requests launched via ClientSession objects."""
+
+    def __init__(
+        self, trace_config_ctx_factory: Type[SimpleNamespace] = SimpleNamespace
+    ) -> None:
+        self._on_request_start = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceRequestStartParams]]
+        self._on_request_chunk_sent = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceRequestChunkSentParams]]
+        self._on_response_chunk_received = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceResponseChunkReceivedParams]]
+        self._on_request_end = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceRequestEndParams]]
+        self._on_request_exception = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceRequestExceptionParams]]
+        self._on_request_redirect = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceRequestRedirectParams]]
+        self._on_connection_queued_start = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceConnectionQueuedStartParams]]
+        self._on_connection_queued_end = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceConnectionQueuedEndParams]]
+        self._on_connection_create_start = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceConnectionCreateStartParams]]
+        self._on_connection_create_end = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceConnectionCreateEndParams]]
+        self._on_connection_reuseconn = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceConnectionReuseconnParams]]
+        self._on_dns_resolvehost_start = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceDnsResolveHostStartParams]]
+        self._on_dns_resolvehost_end = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceDnsResolveHostEndParams]]
+        self._on_dns_cache_hit = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceDnsCacheHitParams]]
+        self._on_dns_cache_miss = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceDnsCacheMissParams]]
+        self._on_request_headers_sent = Signal(
+            self
+        )  # type: Signal[_SignalCallback[TraceRequestHeadersSentParams]]
+
+        self._trace_config_ctx_factory = trace_config_ctx_factory
+
+    def trace_config_ctx(
+        self, trace_request_ctx: Optional[SimpleNamespace] = None
+    ) -> SimpleNamespace:
+        """Return a new trace_config_ctx instance"""
+        return self._trace_config_ctx_factory(trace_request_ctx=trace_request_ctx)
+
+    def freeze(self) -> None:
+        self._on_request_start.freeze()
+        self._on_request_chunk_sent.freeze()
+        self._on_response_chunk_received.freeze()
+        self._on_request_end.freeze()
+        self._on_request_exception.freeze()
+        self._on_request_redirect.freeze()
+        self._on_connection_queued_start.freeze()
+        self._on_connection_queued_end.freeze()
+        self._on_connection_create_start.freeze()
+        self._on_connection_create_end.freeze()
+        self._on_connection_reuseconn.freeze()
+        self._on_dns_resolvehost_start.freeze()
+        self._on_dns_resolvehost_end.freeze()
+        self._on_dns_cache_hit.freeze()
+        self._on_dns_cache_miss.freeze()
+        self._on_request_headers_sent.freeze()
+
+    @property
+    def on_request_start(self) -> "Signal[_SignalCallback[TraceRequestStartParams]]":
+        return self._on_request_start
+
+    @property
+    def on_request_chunk_sent(
+        self,
+    ) -> "Signal[_SignalCallback[TraceRequestChunkSentParams]]":
+        return self._on_request_chunk_sent
+
+    @property
+    def on_response_chunk_received(
+        self,
+    ) -> "Signal[_SignalCallback[TraceResponseChunkReceivedParams]]":
+        return self._on_response_chunk_received
+
+    @property
+    def on_request_end(self) -> "Signal[_SignalCallback[TraceRequestEndParams]]":
+        return self._on_request_end
+
+    @property
+    def on_request_exception(
+        self,
+    ) -> "Signal[_SignalCallback[TraceRequestExceptionParams]]":
+        return self._on_request_exception
+
+    @property
+    def on_request_redirect(
+        self,
+    ) -> "Signal[_SignalCallback[TraceRequestRedirectParams]]":
+        return self._on_request_redirect
+
+    @property
+    def on_connection_queued_start(
+        self,
+    ) -> "Signal[_SignalCallback[TraceConnectionQueuedStartParams]]":
+        return self._on_connection_queued_start
+
+    @property
+    def on_connection_queued_end(
+        self,
+    ) -> "Signal[_SignalCallback[TraceConnectionQueuedEndParams]]":
+        return self._on_connection_queued_end
+
+    @property
+    def on_connection_create_start(
+        self,
+    ) -> "Signal[_SignalCallback[TraceConnectionCreateStartParams]]":
+        return self._on_connection_create_start
+
+    @property
+    def on_connection_create_end(
+        self,
+    ) -> "Signal[_SignalCallback[TraceConnectionCreateEndParams]]":
+        return self._on_connection_create_end
+
+    @property
+    def on_connection_reuseconn(
+        self,
+    ) -> "Signal[_SignalCallback[TraceConnectionReuseconnParams]]":
+        return self._on_connection_reuseconn
+
+    @property
+    def on_dns_resolvehost_start(
+        self,
+    ) -> "Signal[_SignalCallback[TraceDnsResolveHostStartParams]]":
+        return self._on_dns_resolvehost_start
+
+    @property
+    def on_dns_resolvehost_end(
+        self,
+    ) -> "Signal[_SignalCallback[TraceDnsResolveHostEndParams]]":
+        return self._on_dns_resolvehost_end
+
+    @property
+    def on_dns_cache_hit(self) -> "Signal[_SignalCallback[TraceDnsCacheHitParams]]":
+        return self._on_dns_cache_hit
+
+    @property
+    def on_dns_cache_miss(self) -> "Signal[_SignalCallback[TraceDnsCacheMissParams]]":
+        return self._on_dns_cache_miss
+
+    @property
+    def on_request_headers_sent(
+        self,
+    ) -> "Signal[_SignalCallback[TraceRequestHeadersSentParams]]":
+        return self._on_request_headers_sent
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceRequestStartParams:
+    """Parameters sent by the `on_request_start` signal"""
+
+    method: str
+    url: URL
+    headers: "CIMultiDict[str]"
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceRequestChunkSentParams:
+    """Parameters sent by the `on_request_chunk_sent` signal"""
+
+    method: str
+    url: URL
+    chunk: bytes
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceResponseChunkReceivedParams:
+    """Parameters sent by the `on_response_chunk_received` signal"""
+
+    method: str
+    url: URL
+    chunk: bytes
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceRequestEndParams:
+    """Parameters sent by the `on_request_end` signal"""
+
+    method: str
+    url: URL
+    headers: "CIMultiDict[str]"
+    response: ClientResponse
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceRequestExceptionParams:
+    """Parameters sent by the `on_request_exception` signal"""
+
+    method: str
+    url: URL
+    headers: "CIMultiDict[str]"
+    exception: BaseException
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceRequestRedirectParams:
+    """Parameters sent by the `on_request_redirect` signal"""
+
+    method: str
+    url: URL
+    headers: "CIMultiDict[str]"
+    response: ClientResponse
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceConnectionQueuedStartParams:
+    """Parameters sent by the `on_connection_queued_start` signal"""
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceConnectionQueuedEndParams:
+    """Parameters sent by the `on_connection_queued_end` signal"""
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceConnectionCreateStartParams:
+    """Parameters sent by the `on_connection_create_start` signal"""
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceConnectionCreateEndParams:
+    """Parameters sent by the `on_connection_create_end` signal"""
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceConnectionReuseconnParams:
+    """Parameters sent by the `on_connection_reuseconn` signal"""
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceDnsResolveHostStartParams:
+    """Parameters sent by the `on_dns_resolvehost_start` signal"""
+
+    host: str
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceDnsResolveHostEndParams:
+    """Parameters sent by the `on_dns_resolvehost_end` signal"""
+
+    host: str
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceDnsCacheHitParams:
+    """Parameters sent by the `on_dns_cache_hit` signal"""
+
+    host: str
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceDnsCacheMissParams:
+    """Parameters sent by the `on_dns_cache_miss` signal"""
+
+    host: str
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class TraceRequestHeadersSentParams:
+    """Parameters sent by the `on_request_headers_sent` signal"""
+
+    method: str
+    url: URL
+    headers: "CIMultiDict[str]"
+
+
+class Trace:
+    """Internal dependency holder class.
+
+    Used to keep together the main dependencies used
+    at the moment of send a signal.
+    """
+
+    def __init__(
+        self,
+        session: "ClientSession",
+        trace_config: TraceConfig,
+        trace_config_ctx: SimpleNamespace,
+    ) -> None:
+        self._trace_config = trace_config
+        self._trace_config_ctx = trace_config_ctx
+        self._session = session
+
+    async def send_request_start(
+        self, method: str, url: URL, headers: "CIMultiDict[str]"
+    ) -> None:
+        return await self._trace_config.on_request_start.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceRequestStartParams(method, url, headers),
+        )
+
+    async def send_request_chunk_sent(
+        self, method: str, url: URL, chunk: bytes
+    ) -> None:
+        return await self._trace_config.on_request_chunk_sent.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceRequestChunkSentParams(method, url, chunk),
+        )
+
+    async def send_response_chunk_received(
+        self, method: str, url: URL, chunk: bytes
+    ) -> None:
+        return await self._trace_config.on_response_chunk_received.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceResponseChunkReceivedParams(method, url, chunk),
+        )
+
+    async def send_request_end(
+        self,
+        method: str,
+        url: URL,
+        headers: "CIMultiDict[str]",
+        response: ClientResponse,
+    ) -> None:
+        return await self._trace_config.on_request_end.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceRequestEndParams(method, url, headers, response),
+        )
+
+    async def send_request_exception(
+        self,
+        method: str,
+        url: URL,
+        headers: "CIMultiDict[str]",
+        exception: BaseException,
+    ) -> None:
+        return await self._trace_config.on_request_exception.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceRequestExceptionParams(method, url, headers, exception),
+        )
+
+    async def send_request_redirect(
+        self,
+        method: str,
+        url: URL,
+        headers: "CIMultiDict[str]",
+        response: ClientResponse,
+    ) -> None:
+        return await self._trace_config._on_request_redirect.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceRequestRedirectParams(method, url, headers, response),
+        )
+
+    async def send_connection_queued_start(self) -> None:
+        return await self._trace_config.on_connection_queued_start.send(
+            self._session, self._trace_config_ctx, TraceConnectionQueuedStartParams()
+        )
+
+    async def send_connection_queued_end(self) -> None:
+        return await self._trace_config.on_connection_queued_end.send(
+            self._session, self._trace_config_ctx, TraceConnectionQueuedEndParams()
+        )
+
+    async def send_connection_create_start(self) -> None:
+        return await self._trace_config.on_connection_create_start.send(
+            self._session, self._trace_config_ctx, TraceConnectionCreateStartParams()
+        )
+
+    async def send_connection_create_end(self) -> None:
+        return await self._trace_config.on_connection_create_end.send(
+            self._session, self._trace_config_ctx, TraceConnectionCreateEndParams()
+        )
+
+    async def send_connection_reuseconn(self) -> None:
+        return await self._trace_config.on_connection_reuseconn.send(
+            self._session, self._trace_config_ctx, TraceConnectionReuseconnParams()
+        )
+
+    async def send_dns_resolvehost_start(self, host: str) -> None:
+        return await self._trace_config.on_dns_resolvehost_start.send(
+            self._session, self._trace_config_ctx, TraceDnsResolveHostStartParams(host)
+        )
+
+    async def send_dns_resolvehost_end(self, host: str) -> None:
+        return await self._trace_config.on_dns_resolvehost_end.send(
+            self._session, self._trace_config_ctx, TraceDnsResolveHostEndParams(host)
+        )
+
+    async def send_dns_cache_hit(self, host: str) -> None:
+        return await self._trace_config.on_dns_cache_hit.send(
+            self._session, self._trace_config_ctx, TraceDnsCacheHitParams(host)
+        )
+
+    async def send_dns_cache_miss(self, host: str) -> None:
+        return await self._trace_config.on_dns_cache_miss.send(
+            self._session, self._trace_config_ctx, TraceDnsCacheMissParams(host)
+        )
+
+    async def send_request_headers(
+        self, method: str, url: URL, headers: "CIMultiDict[str]"
+    ) -> None:
+        return await self._trace_config._on_request_headers_sent.send(
+            self._session,
+            self._trace_config_ctx,
+            TraceRequestHeadersSentParams(method, url, headers),
+        )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/typedefs.py

@@ -0,0 +1,64 @@
+import json
+import os
+import sys
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Iterable,
+    Mapping,
+    Tuple,
+    Union,
+)
+
+from multidict import CIMultiDict, CIMultiDictProxy, MultiDict, MultiDictProxy, istr
+from yarl import URL
+
+# These are for other modules to use (to avoid repeating the conditional import).
+if sys.version_info >= (3, 8):
+    from typing import Final as Final, Protocol as Protocol, TypedDict as TypedDict
+else:
+    from typing_extensions import (  # noqa: F401
+        Final,
+        Protocol as Protocol,
+        TypedDict as TypedDict,
+    )
+
+DEFAULT_JSON_ENCODER = json.dumps
+DEFAULT_JSON_DECODER = json.loads
+
+if TYPE_CHECKING:  # pragma: no cover
+    _CIMultiDict = CIMultiDict[str]
+    _CIMultiDictProxy = CIMultiDictProxy[str]
+    _MultiDict = MultiDict[str]
+    _MultiDictProxy = MultiDictProxy[str]
+    from http.cookies import BaseCookie, Morsel
+
+    from .web import Request, StreamResponse
+else:
+    _CIMultiDict = CIMultiDict
+    _CIMultiDictProxy = CIMultiDictProxy
+    _MultiDict = MultiDict
+    _MultiDictProxy = MultiDictProxy
+
+Byteish = Union[bytes, bytearray, memoryview]
+JSONEncoder = Callable[[Any], str]
+JSONDecoder = Callable[[str], Any]
+LooseHeaders = Union[Mapping[Union[str, istr], str], _CIMultiDict, _CIMultiDictProxy]
+RawHeaders = Tuple[Tuple[bytes, bytes], ...]
+StrOrURL = Union[str, URL]
+
+LooseCookiesMappings = Mapping[str, Union[str, "BaseCookie[str]", "Morsel[Any]"]]
+LooseCookiesIterables = Iterable[
+    Tuple[str, Union[str, "BaseCookie[str]", "Morsel[Any]"]]
+]
+LooseCookies = Union[
+    LooseCookiesMappings,
+    LooseCookiesIterables,
+    "BaseCookie[str]",
+]
+
+Handler = Callable[["Request"], Awaitable["StreamResponse"]]
+
+PathLike = Union[str, "os.PathLike[str]"]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/web_middlewares.py

@@ -0,0 +1,119 @@
+import re
+from typing import TYPE_CHECKING, Awaitable, Callable, Tuple, Type, TypeVar
+
+from .typedefs import Handler
+from .web_exceptions import HTTPPermanentRedirect, _HTTPMove
+from .web_request import Request
+from .web_response import StreamResponse
+from .web_urldispatcher import SystemRoute
+
+__all__ = (
+    "middleware",
+    "normalize_path_middleware",
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .web_app import Application
+
+_Func = TypeVar("_Func")
+
+
+async def _check_request_resolves(request: Request, path: str) -> Tuple[bool, Request]:
+    alt_request = request.clone(rel_url=path)
+
+    match_info = await request.app.router.resolve(alt_request)
+    alt_request._match_info = match_info
+
+    if match_info.http_exception is None:
+        return True, alt_request
+
+    return False, request
+
+
+def middleware(f: _Func) -> _Func:
+    f.__middleware_version__ = 1  # type: ignore[attr-defined]
+    return f
+
+
+_Middleware = Callable[[Request, Handler], Awaitable[StreamResponse]]
+
+
+def normalize_path_middleware(
+    *,
+    append_slash: bool = True,
+    remove_slash: bool = False,
+    merge_slashes: bool = True,
+    redirect_class: Type[_HTTPMove] = HTTPPermanentRedirect,
+) -> _Middleware:
+    """Factory for producing a middleware that normalizes the path of a request.
+
+    Normalizing means:
+        - Add or remove a trailing slash to the path.
+        - Double slashes are replaced by one.
+
+    The middleware returns as soon as it finds a path that resolves
+    correctly. The order if both merge and append/remove are enabled is
+        1) merge slashes
+        2) append/remove slash
+        3) both merge slashes and append/remove slash.
+    If the path resolves with at least one of those conditions, it will
+    redirect to the new path.
+
+    Only one of `append_slash` and `remove_slash` can be enabled. If both
+    are `True` the factory will raise an assertion error
+
+    If `append_slash` is `True` the middleware will append a slash when
+    needed. If a resource is defined with trailing slash and the request
+    comes without it, it will append it automatically.
+
+    If `remove_slash` is `True`, `append_slash` must be `False`. When enabled
+    the middleware will remove trailing slashes and redirect if the resource
+    is defined
+
+    If merge_slashes is True, merge multiple consecutive slashes in the
+    path into one.
+    """
+    correct_configuration = not (append_slash and remove_slash)
+    assert correct_configuration, "Cannot both remove and append slash"
+
+    @middleware
+    async def impl(request: Request, handler: Handler) -> StreamResponse:
+        if isinstance(request.match_info.route, SystemRoute):
+            paths_to_check = []
+            if "?" in request.raw_path:
+                path, query = request.raw_path.split("?", 1)
+                query = "?" + query
+            else:
+                query = ""
+                path = request.raw_path
+
+            if merge_slashes:
+                paths_to_check.append(re.sub("//+", "/", path))
+            if append_slash and not request.path.endswith("/"):
+                paths_to_check.append(path + "/")
+            if remove_slash and request.path.endswith("/"):
+                paths_to_check.append(path[:-1])
+            if merge_slashes and append_slash:
+                paths_to_check.append(re.sub("//+", "/", path + "/"))
+            if merge_slashes and remove_slash:
+                merged_slashes = re.sub("//+", "/", path)
+                paths_to_check.append(merged_slashes[:-1])
+
+            for path in paths_to_check:
+                path = re.sub("^//+", "/", path)  # SECURITY: GHSA-v6wp-4m6f-gcjg
+                resolves, request = await _check_request_resolves(request, path)
+                if resolves:
+                    raise redirect_class(request.raw_path + query)
+
+        return await handler(request)
+
+    return impl
+
+
+def _fix_request_current_app(app: "Application") -> _Middleware:
+    @middleware
+    async def impl(request: Request, handler: Handler) -> StreamResponse:
+        with request.match_info.set_current_app(app):
+            return await handler(request)
+
+    return impl

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/web_protocol.py

@@ -0,0 +1,681 @@
+import asyncio
+import asyncio.streams
+import traceback
+import warnings
+from collections import deque
+from contextlib import suppress
+from html import escape as html_escape
+from http import HTTPStatus
+from logging import Logger
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Deque,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+import attr
+import yarl
+
+from .abc import AbstractAccessLogger, AbstractStreamWriter
+from .base_protocol import BaseProtocol
+from .helpers import ceil_timeout
+from .http import (
+    HttpProcessingError,
+    HttpRequestParser,
+    HttpVersion10,
+    RawRequestMessage,
+    StreamWriter,
+)
+from .log import access_logger, server_logger
+from .streams import EMPTY_PAYLOAD, StreamReader
+from .tcp_helpers import tcp_keepalive
+from .web_exceptions import HTTPException
+from .web_log import AccessLogger
+from .web_request import BaseRequest
+from .web_response import Response, StreamResponse
+
+__all__ = ("RequestHandler", "RequestPayloadError", "PayloadAccessError")
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .web_server import Server
+
+
+_RequestFactory = Callable[
+    [
+        RawRequestMessage,
+        StreamReader,
+        "RequestHandler",
+        AbstractStreamWriter,
+        "asyncio.Task[None]",
+    ],
+    BaseRequest,
+]
+
+_RequestHandler = Callable[[BaseRequest], Awaitable[StreamResponse]]
+
+ERROR = RawRequestMessage(
+    "UNKNOWN",
+    "/",
+    HttpVersion10,
+    {},  # type: ignore[arg-type]
+    {},  # type: ignore[arg-type]
+    True,
+    None,
+    False,
+    False,
+    yarl.URL("/"),
+)
+
+
+class RequestPayloadError(Exception):
+    """Payload parsing error."""
+
+
+class PayloadAccessError(Exception):
+    """Payload was accessed after response was sent."""
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class _ErrInfo:
+    status: int
+    exc: BaseException
+    message: str
+
+
+_MsgType = Tuple[Union[RawRequestMessage, _ErrInfo], StreamReader]
+
+
+class RequestHandler(BaseProtocol):
+    """HTTP protocol implementation.
+
+    RequestHandler handles incoming HTTP request. It reads request line,
+    request headers and request payload and calls handle_request() method.
+    By default it always returns with 404 response.
+
+    RequestHandler handles errors in incoming request, like bad
+    status line, bad headers or incomplete payload. If any error occurs,
+    connection gets closed.
+
+    keepalive_timeout -- number of seconds before closing
+                         keep-alive connection
+
+    tcp_keepalive -- TCP keep-alive is on, default is on
+
+    debug -- enable debug mode
+
+    logger -- custom logger object
+
+    access_log_class -- custom class for access_logger
+
+    access_log -- custom logging object
+
+    access_log_format -- access log format string
+
+    loop -- Optional event loop
+
+    max_line_size -- Optional maximum header line size
+
+    max_field_size -- Optional maximum header field size
+
+    max_headers -- Optional maximum header size
+
+    """
+
+    KEEPALIVE_RESCHEDULE_DELAY = 1
+
+    __slots__ = (
+        "_request_count",
+        "_keepalive",
+        "_manager",
+        "_request_handler",
+        "_request_factory",
+        "_tcp_keepalive",
+        "_keepalive_time",
+        "_keepalive_handle",
+        "_keepalive_timeout",
+        "_lingering_time",
+        "_messages",
+        "_message_tail",
+        "_waiter",
+        "_task_handler",
+        "_upgrade",
+        "_payload_parser",
+        "_request_parser",
+        "_reading_paused",
+        "logger",
+        "debug",
+        "access_log",
+        "access_logger",
+        "_close",
+        "_force_close",
+        "_current_request",
+    )
+
+    def __init__(
+        self,
+        manager: "Server",
+        *,
+        loop: asyncio.AbstractEventLoop,
+        keepalive_timeout: float = 75.0,  # NGINX default is 75 secs
+        tcp_keepalive: bool = True,
+        logger: Logger = server_logger,
+        access_log_class: Type[AbstractAccessLogger] = AccessLogger,
+        access_log: Logger = access_logger,
+        access_log_format: str = AccessLogger.LOG_FORMAT,
+        debug: bool = False,
+        max_line_size: int = 8190,
+        max_headers: int = 32768,
+        max_field_size: int = 8190,
+        lingering_time: float = 10.0,
+        read_bufsize: int = 2 ** 16,
+        auto_decompress: bool = True,
+    ):
+        super().__init__(loop)
+
+        self._request_count = 0
+        self._keepalive = False
+        self._current_request = None  # type: Optional[BaseRequest]
+        self._manager = manager  # type: Optional[Server]
+        self._request_handler: Optional[_RequestHandler] = manager.request_handler
+        self._request_factory: Optional[_RequestFactory] = manager.request_factory
+
+        self._tcp_keepalive = tcp_keepalive
+        # placeholder to be replaced on keepalive timeout setup
+        self._keepalive_time = 0.0
+        self._keepalive_handle = None  # type: Optional[asyncio.Handle]
+        self._keepalive_timeout = keepalive_timeout
+        self._lingering_time = float(lingering_time)
+
+        self._messages: Deque[_MsgType] = deque()
+        self._message_tail = b""
+
+        self._waiter = None  # type: Optional[asyncio.Future[None]]
+        self._task_handler = None  # type: Optional[asyncio.Task[None]]
+
+        self._upgrade = False
+        self._payload_parser = None  # type: Any
+        self._request_parser = HttpRequestParser(
+            self,
+            loop,
+            read_bufsize,
+            max_line_size=max_line_size,
+            max_field_size=max_field_size,
+            max_headers=max_headers,
+            payload_exception=RequestPayloadError,
+            auto_decompress=auto_decompress,
+        )  # type: Optional[HttpRequestParser]
+
+        self.logger = logger
+        self.debug = debug
+        self.access_log = access_log
+        if access_log:
+            self.access_logger = access_log_class(
+                access_log, access_log_format
+            )  # type: Optional[AbstractAccessLogger]
+        else:
+            self.access_logger = None
+
+        self._close = False
+        self._force_close = False
+
+    def __repr__(self) -> str:
+        return "<{} {}>".format(
+            self.__class__.__name__,
+            "connected" if self.transport is not None else "disconnected",
+        )
+
+    @property
+    def keepalive_timeout(self) -> float:
+        return self._keepalive_timeout
+
+    async def shutdown(self, timeout: Optional[float] = 15.0) -> None:
+        """Do worker process exit preparations.
+
+        We need to clean up everything and stop accepting requests.
+        It is especially important for keep-alive connections.
+        """
+        self._force_close = True
+
+        if self._keepalive_handle is not None:
+            self._keepalive_handle.cancel()
+
+        if self._waiter:
+            self._waiter.cancel()
+
+        # wait for handlers
+        with suppress(asyncio.CancelledError, asyncio.TimeoutError):
+            async with ceil_timeout(timeout):
+                if self._current_request is not None:
+                    self._current_request._cancel(asyncio.CancelledError())
+
+                if self._task_handler is not None and not self._task_handler.done():
+                    await self._task_handler
+
+        # force-close non-idle handler
+        if self._task_handler is not None:
+            self._task_handler.cancel()
+
+        if self.transport is not None:
+            self.transport.close()
+            self.transport = None
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        super().connection_made(transport)
+
+        real_transport = cast(asyncio.Transport, transport)
+        if self._tcp_keepalive:
+            tcp_keepalive(real_transport)
+
+        self._task_handler = self._loop.create_task(self.start())
+        assert self._manager is not None
+        self._manager.connection_made(self, real_transport)
+
+    def connection_lost(self, exc: Optional[BaseException]) -> None:
+        if self._manager is None:
+            return
+        self._manager.connection_lost(self, exc)
+
+        super().connection_lost(exc)
+
+        self._manager = None
+        self._force_close = True
+        self._request_factory = None
+        self._request_handler = None
+        self._request_parser = None
+
+        if self._keepalive_handle is not None:
+            self._keepalive_handle.cancel()
+
+        if self._current_request is not None:
+            if exc is None:
+                exc = ConnectionResetError("Connection lost")
+            self._current_request._cancel(exc)
+
+        if self._task_handler is not None:
+            self._task_handler.cancel()
+        if self._waiter is not None:
+            self._waiter.cancel()
+
+        self._task_handler = None
+
+        if self._payload_parser is not None:
+            self._payload_parser.feed_eof()
+            self._payload_parser = None
+
+    def set_parser(self, parser: Any) -> None:
+        # Actual type is WebReader
+        assert self._payload_parser is None
+
+        self._payload_parser = parser
+
+        if self._message_tail:
+            self._payload_parser.feed_data(self._message_tail)
+            self._message_tail = b""
+
+    def eof_received(self) -> None:
+        pass
+
+    def data_received(self, data: bytes) -> None:
+        if self._force_close or self._close:
+            return
+        # parse http messages
+        messages: Sequence[_MsgType]
+        if self._payload_parser is None and not self._upgrade:
+            assert self._request_parser is not None
+            try:
+                messages, upgraded, tail = self._request_parser.feed_data(data)
+            except HttpProcessingError as exc:
+                messages = [
+                    (_ErrInfo(status=400, exc=exc, message=exc.message), EMPTY_PAYLOAD)
+                ]
+                upgraded = False
+                tail = b""
+
+            for msg, payload in messages or ():
+                self._request_count += 1
+                self._messages.append((msg, payload))
+
+            waiter = self._waiter
+            if messages and waiter is not None and not waiter.done():
+                # don't set result twice
+                waiter.set_result(None)
+
+            self._upgrade = upgraded
+            if upgraded and tail:
+                self._message_tail = tail
+
+        # no parser, just store
+        elif self._payload_parser is None and self._upgrade and data:
+            self._message_tail += data
+
+        # feed payload
+        elif data:
+            eof, tail = self._payload_parser.feed_data(data)
+            if eof:
+                self.close()
+
+    def keep_alive(self, val: bool) -> None:
+        """Set keep-alive connection mode.
+
+        :param bool val: new state.
+        """
+        self._keepalive = val
+        if self._keepalive_handle:
+            self._keepalive_handle.cancel()
+            self._keepalive_handle = None
+
+    def close(self) -> None:
+        """Close connection.
+
+        Stop accepting new pipelining messages and close
+        connection when handlers done processing messages.
+        """
+        self._close = True
+        if self._waiter:
+            self._waiter.cancel()
+
+    def force_close(self) -> None:
+        """Forcefully close connection."""
+        self._force_close = True
+        if self._waiter:
+            self._waiter.cancel()
+        if self.transport is not None:
+            self.transport.close()
+            self.transport = None
+
+    def log_access(
+        self, request: BaseRequest, response: StreamResponse, time: float
+    ) -> None:
+        if self.access_logger is not None:
+            self.access_logger.log(request, response, self._loop.time() - time)
+
+    def log_debug(self, *args: Any, **kw: Any) -> None:
+        if self.debug:
+            self.logger.debug(*args, **kw)
+
+    def log_exception(self, *args: Any, **kw: Any) -> None:
+        self.logger.exception(*args, **kw)
+
+    def _process_keepalive(self) -> None:
+        if self._force_close or not self._keepalive:
+            return
+
+        next = self._keepalive_time + self._keepalive_timeout
+
+        # handler in idle state
+        if self._waiter:
+            if self._loop.time() > next:
+                self.force_close()
+                return
+
+        # not all request handlers are done,
+        # reschedule itself to next second
+        self._keepalive_handle = self._loop.call_later(
+            self.KEEPALIVE_RESCHEDULE_DELAY, self._process_keepalive
+        )
+
+    async def _handle_request(
+        self,
+        request: BaseRequest,
+        start_time: float,
+        request_handler: Callable[[BaseRequest], Awaitable[StreamResponse]],
+    ) -> Tuple[StreamResponse, bool]:
+        assert self._request_handler is not None
+        try:
+            try:
+                self._current_request = request
+                resp = await request_handler(request)
+            finally:
+                self._current_request = None
+        except HTTPException as exc:
+            resp = exc
+            reset = await self.finish_response(request, resp, start_time)
+        except asyncio.CancelledError:
+            raise
+        except asyncio.TimeoutError as exc:
+            self.log_debug("Request handler timed out.", exc_info=exc)
+            resp = self.handle_error(request, 504)
+            reset = await self.finish_response(request, resp, start_time)
+        except Exception as exc:
+            resp = self.handle_error(request, 500, exc)
+            reset = await self.finish_response(request, resp, start_time)
+        else:
+            # Deprecation warning (See #2415)
+            if getattr(resp, "__http_exception__", False):
+                warnings.warn(
+                    "returning HTTPException object is deprecated "
+                    "(#2415) and will be removed, "
+                    "please raise the exception instead",
+                    DeprecationWarning,
+                )
+
+            reset = await self.finish_response(request, resp, start_time)
+
+        return resp, reset
+
+    async def start(self) -> None:
+        """Process incoming request.
+
+        It reads request line, request headers and request payload, then
+        calls handle_request() method. Subclass has to override
+        handle_request(). start() handles various exceptions in request
+        or response handling. Connection is being closed always unless
+        keep_alive(True) specified.
+        """
+        loop = self._loop
+        handler = self._task_handler
+        assert handler is not None
+        manager = self._manager
+        assert manager is not None
+        keepalive_timeout = self._keepalive_timeout
+        resp = None
+        assert self._request_factory is not None
+        assert self._request_handler is not None
+
+        while not self._force_close:
+            if not self._messages:
+                try:
+                    # wait for next request
+                    self._waiter = loop.create_future()
+                    await self._waiter
+                except asyncio.CancelledError:
+                    break
+                finally:
+                    self._waiter = None
+
+            message, payload = self._messages.popleft()
+
+            start = loop.time()
+
+            manager.requests_count += 1
+            writer = StreamWriter(self, loop)
+            if isinstance(message, _ErrInfo):
+                # make request_factory work
+                request_handler = self._make_error_handler(message)
+                message = ERROR
+            else:
+                request_handler = self._request_handler
+
+            request = self._request_factory(message, payload, self, writer, handler)
+            try:
+                # a new task is used for copy context vars (#3406)
+                task = self._loop.create_task(
+                    self._handle_request(request, start, request_handler)
+                )
+                try:
+                    resp, reset = await task
+                except (asyncio.CancelledError, ConnectionError):
+                    self.log_debug("Ignored premature client disconnection")
+                    break
+
+                # Drop the processed task from asyncio.Task.all_tasks() early
+                del task
+                if reset:
+                    self.log_debug("Ignored premature client disconnection 2")
+                    break
+
+                # notify server about keep-alive
+                self._keepalive = bool(resp.keep_alive)
+
+                # check payload
+                if not payload.is_eof():
+                    lingering_time = self._lingering_time
+                    if not self._force_close and lingering_time:
+                        self.log_debug(
+                            "Start lingering close timer for %s sec.", lingering_time
+                        )
+
+                        now = loop.time()
+                        end_t = now + lingering_time
+
+                        with suppress(asyncio.TimeoutError, asyncio.CancelledError):
+                            while not payload.is_eof() and now < end_t:
+                                async with ceil_timeout(end_t - now):
+                                    # read and ignore
+                                    await payload.readany()
+                                now = loop.time()
+
+                    # if payload still uncompleted
+                    if not payload.is_eof() and not self._force_close:
+                        self.log_debug("Uncompleted request.")
+                        self.close()
+
+                payload.set_exception(PayloadAccessError())
+
+            except asyncio.CancelledError:
+                self.log_debug("Ignored premature client disconnection ")
+                break
+            except RuntimeError as exc:
+                if self.debug:
+                    self.log_exception("Unhandled runtime exception", exc_info=exc)
+                self.force_close()
+            except Exception as exc:
+                self.log_exception("Unhandled exception", exc_info=exc)
+                self.force_close()
+            finally:
+                if self.transport is None and resp is not None:
+                    self.log_debug("Ignored premature client disconnection.")
+                elif not self._force_close:
+                    if self._keepalive and not self._close:
+                        # start keep-alive timer
+                        if keepalive_timeout is not None:
+                            now = self._loop.time()
+                            self._keepalive_time = now
+                            if self._keepalive_handle is None:
+                                self._keepalive_handle = loop.call_at(
+                                    now + keepalive_timeout, self._process_keepalive
+                                )
+                    else:
+                        break
+
+        # remove handler, close transport if no handlers left
+        if not self._force_close:
+            self._task_handler = None
+            if self.transport is not None:
+                self.transport.close()
+
+    async def finish_response(
+        self, request: BaseRequest, resp: StreamResponse, start_time: float
+    ) -> bool:
+        """Prepare the response and write_eof, then log access.
+
+        This has to
+        be called within the context of any exception so the access logger
+        can get exception information. Returns True if the client disconnects
+        prematurely.
+        """
+        if self._request_parser is not None:
+            self._request_parser.set_upgraded(False)
+            self._upgrade = False
+            if self._message_tail:
+                self._request_parser.feed_data(self._message_tail)
+                self._message_tail = b""
+        try:
+            prepare_meth = resp.prepare
+        except AttributeError:
+            if resp is None:
+                raise RuntimeError("Missing return " "statement on request handler")
+            else:
+                raise RuntimeError(
+                    "Web-handler should return "
+                    "a response instance, "
+                    "got {!r}".format(resp)
+                )
+        try:
+            await prepare_meth(request)
+            await resp.write_eof()
+        except ConnectionError:
+            self.log_access(request, resp, start_time)
+            return True
+        else:
+            self.log_access(request, resp, start_time)
+            return False
+
+    def handle_error(
+        self,
+        request: BaseRequest,
+        status: int = 500,
+        exc: Optional[BaseException] = None,
+        message: Optional[str] = None,
+    ) -> StreamResponse:
+        """Handle errors.
+
+        Returns HTTP response with specific status code. Logs additional
+        information. It always closes current connection.
+        """
+        self.log_exception("Error handling request", exc_info=exc)
+
+        # some data already got sent, connection is broken
+        if request.writer.output_size > 0:
+            raise ConnectionError(
+                "Response is sent already, cannot send another response "
+                "with the error message"
+            )
+
+        ct = "text/plain"
+        if status == HTTPStatus.INTERNAL_SERVER_ERROR:
+            title = "{0.value} {0.phrase}".format(HTTPStatus.INTERNAL_SERVER_ERROR)
+            msg = HTTPStatus.INTERNAL_SERVER_ERROR.description
+            tb = None
+            if self.debug:
+                with suppress(Exception):
+                    tb = traceback.format_exc()
+
+            if "text/html" in request.headers.get("Accept", ""):
+                if tb:
+                    tb = html_escape(tb)
+                    msg = f"<h2>Traceback:</h2>\n<pre>{tb}</pre>"
+                message = (
+                    "<html><head>"
+                    "<title>{title}</title>"
+                    "</head><body>\n<h1>{title}</h1>"
+                    "\n{msg}\n</body></html>\n"
+                ).format(title=title, msg=msg)
+                ct = "text/html"
+            else:
+                if tb:
+                    msg = tb
+                message = title + "\n\n" + msg
+
+        resp = Response(status=status, text=message, content_type=ct)
+        resp.force_close()
+
+        return resp
+
+    def _make_error_handler(
+        self, err_info: _ErrInfo
+    ) -> Callable[[BaseRequest], Awaitable[StreamResponse]]:
+        async def handler(request: BaseRequest) -> StreamResponse:
+            return self.handle_error(
+                request, err_info.status, err_info.exc, err_info.message
+            )
+
+        return handler

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/web_routedef.py

@@ -0,0 +1,213 @@
+import abc
+import os  # noqa
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+    overload,
+)
+
+import attr
+
+from . import hdrs
+from .abc import AbstractView
+from .typedefs import Handler, PathLike
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .web_request import Request
+    from .web_response import StreamResponse
+    from .web_urldispatcher import AbstractRoute, UrlDispatcher
+else:
+    Request = StreamResponse = UrlDispatcher = AbstractRoute = None
+
+
+__all__ = (
+    "AbstractRouteDef",
+    "RouteDef",
+    "StaticDef",
+    "RouteTableDef",
+    "head",
+    "options",
+    "get",
+    "post",
+    "patch",
+    "put",
+    "delete",
+    "route",
+    "view",
+    "static",
+)
+
+
+class AbstractRouteDef(abc.ABC):
+    @abc.abstractmethod
+    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
+        pass  # pragma: no cover
+
+
+_HandlerType = Union[Type[AbstractView], Handler]
+
+
+@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
+class RouteDef(AbstractRouteDef):
+    method: str
+    path: str
+    handler: _HandlerType
+    kwargs: Dict[str, Any]
+
+    def __repr__(self) -> str:
+        info = []
+        for name, value in sorted(self.kwargs.items()):
+            info.append(f", {name}={value!r}")
+        return "<RouteDef {method} {path} -> {handler.__name__!r}" "{info}>".format(
+            method=self.method, path=self.path, handler=self.handler, info="".join(info)
+        )
+
+    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
+        if self.method in hdrs.METH_ALL:
+            reg = getattr(router, "add_" + self.method.lower())
+            return [reg(self.path, self.handler, **self.kwargs)]
+        else:
+            return [
+                router.add_route(self.method, self.path, self.handler, **self.kwargs)
+            ]
+
+
+@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
+class StaticDef(AbstractRouteDef):
+    prefix: str
+    path: PathLike
+    kwargs: Dict[str, Any]
+
+    def __repr__(self) -> str:
+        info = []
+        for name, value in sorted(self.kwargs.items()):
+            info.append(f", {name}={value!r}")
+        return "<StaticDef {prefix} -> {path}" "{info}>".format(
+            prefix=self.prefix, path=self.path, info="".join(info)
+        )
+
+    def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
+        resource = router.add_static(self.prefix, self.path, **self.kwargs)
+        routes = resource.get_info().get("routes", {})
+        return list(routes.values())
+
+
+def route(method: str, path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return RouteDef(method, path, handler, kwargs)
+
+
+def head(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_HEAD, path, handler, **kwargs)
+
+
+def options(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_OPTIONS, path, handler, **kwargs)
+
+
+def get(
+    path: str,
+    handler: _HandlerType,
+    *,
+    name: Optional[str] = None,
+    allow_head: bool = True,
+    **kwargs: Any,
+) -> RouteDef:
+    return route(
+        hdrs.METH_GET, path, handler, name=name, allow_head=allow_head, **kwargs
+    )
+
+
+def post(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_POST, path, handler, **kwargs)
+
+
+def put(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_PUT, path, handler, **kwargs)
+
+
+def patch(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_PATCH, path, handler, **kwargs)
+
+
+def delete(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_DELETE, path, handler, **kwargs)
+
+
+def view(path: str, handler: Type[AbstractView], **kwargs: Any) -> RouteDef:
+    return route(hdrs.METH_ANY, path, handler, **kwargs)
+
+
+def static(prefix: str, path: PathLike, **kwargs: Any) -> StaticDef:
+    return StaticDef(prefix, path, kwargs)
+
+
+_Deco = Callable[[_HandlerType], _HandlerType]
+
+
+class RouteTableDef(Sequence[AbstractRouteDef]):
+    """Route definition table"""
+
+    def __init__(self) -> None:
+        self._items = []  # type: List[AbstractRouteDef]
+
+    def __repr__(self) -> str:
+        return f"<RouteTableDef count={len(self._items)}>"
+
+    @overload
+    def __getitem__(self, index: int) -> AbstractRouteDef:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> List[AbstractRouteDef]:
+        ...
+
+    def __getitem__(self, index):  # type: ignore[no-untyped-def]
+        return self._items[index]
+
+    def __iter__(self) -> Iterator[AbstractRouteDef]:
+        return iter(self._items)
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __contains__(self, item: object) -> bool:
+        return item in self._items
+
+    def route(self, method: str, path: str, **kwargs: Any) -> _Deco:
+        def inner(handler: _HandlerType) -> _HandlerType:
+            self._items.append(RouteDef(method, path, handler, kwargs))
+            return handler
+
+        return inner
+
+    def head(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_HEAD, path, **kwargs)
+
+    def get(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_GET, path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_POST, path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_PUT, path, **kwargs)
+
+    def patch(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_PATCH, path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_DELETE, path, **kwargs)
+
+    def view(self, path: str, **kwargs: Any) -> _Deco:
+        return self.route(hdrs.METH_ANY, path, **kwargs)
+
+    def static(self, prefix: str, path: PathLike, **kwargs: Any) -> None:
+        self._items.append(StaticDef(prefix, path, kwargs))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/web_runner.py

@@ -0,0 +1,381 @@
+import asyncio
+import signal
+import socket
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional, Set
+
+from yarl import URL
+
+from .web_app import Application
+from .web_server import Server
+
+try:
+    from ssl import SSLContext
+except ImportError:
+    SSLContext = object  # type: ignore[misc,assignment]
+
+
+__all__ = (
+    "BaseSite",
+    "TCPSite",
+    "UnixSite",
+    "NamedPipeSite",
+    "SockSite",
+    "BaseRunner",
+    "AppRunner",
+    "ServerRunner",
+    "GracefulExit",
+)
+
+
+class GracefulExit(SystemExit):
+    code = 1
+
+
+def _raise_graceful_exit() -> None:
+    raise GracefulExit()
+
+
+class BaseSite(ABC):
+    __slots__ = ("_runner", "_shutdown_timeout", "_ssl_context", "_backlog", "_server")
+
+    def __init__(
+        self,
+        runner: "BaseRunner",
+        *,
+        shutdown_timeout: float = 60.0,
+        ssl_context: Optional[SSLContext] = None,
+        backlog: int = 128,
+    ) -> None:
+        if runner.server is None:
+            raise RuntimeError("Call runner.setup() before making a site")
+        self._runner = runner
+        self._shutdown_timeout = shutdown_timeout
+        self._ssl_context = ssl_context
+        self._backlog = backlog
+        self._server = None  # type: Optional[asyncio.AbstractServer]
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    async def start(self) -> None:
+        self._runner._reg_site(self)
+
+    async def stop(self) -> None:
+        self._runner._check_site(self)
+        if self._server is None:
+            self._runner._unreg_site(self)
+            return  # not started yet
+        self._server.close()
+        # named pipes do not have wait_closed property
+        if hasattr(self._server, "wait_closed"):
+            await self._server.wait_closed()
+        await self._runner.shutdown()
+        assert self._runner.server
+        await self._runner.server.shutdown(self._shutdown_timeout)
+        self._runner._unreg_site(self)
+
+
+class TCPSite(BaseSite):
+    __slots__ = ("_host", "_port", "_reuse_address", "_reuse_port")
+
+    def __init__(
+        self,
+        runner: "BaseRunner",
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        *,
+        shutdown_timeout: float = 60.0,
+        ssl_context: Optional[SSLContext] = None,
+        backlog: int = 128,
+        reuse_address: Optional[bool] = None,
+        reuse_port: Optional[bool] = None,
+    ) -> None:
+        super().__init__(
+            runner,
+            shutdown_timeout=shutdown_timeout,
+            ssl_context=ssl_context,
+            backlog=backlog,
+        )
+        self._host = host
+        if port is None:
+            port = 8443 if self._ssl_context else 8080
+        self._port = port
+        self._reuse_address = reuse_address
+        self._reuse_port = reuse_port
+
+    @property
+    def name(self) -> str:
+        scheme = "https" if self._ssl_context else "http"
+        host = "0.0.0.0" if self._host is None else self._host
+        return str(URL.build(scheme=scheme, host=host, port=self._port))
+
+    async def start(self) -> None:
+        await super().start()
+        loop = asyncio.get_event_loop()
+        server = self._runner.server
+        assert server is not None
+        self._server = await loop.create_server(
+            server,
+            self._host,
+            self._port,
+            ssl=self._ssl_context,
+            backlog=self._backlog,
+            reuse_address=self._reuse_address,
+            reuse_port=self._reuse_port,
+        )
+
+
+class UnixSite(BaseSite):
+    __slots__ = ("_path",)
+
+    def __init__(
+        self,
+        runner: "BaseRunner",
+        path: str,
+        *,
+        shutdown_timeout: float = 60.0,
+        ssl_context: Optional[SSLContext] = None,
+        backlog: int = 128,
+    ) -> None:
+        super().__init__(
+            runner,
+            shutdown_timeout=shutdown_timeout,
+            ssl_context=ssl_context,
+            backlog=backlog,
+        )
+        self._path = path
+
+    @property
+    def name(self) -> str:
+        scheme = "https" if self._ssl_context else "http"
+        return f"{scheme}://unix:{self._path}:"
+
+    async def start(self) -> None:
+        await super().start()
+        loop = asyncio.get_event_loop()
+        server = self._runner.server
+        assert server is not None
+        self._server = await loop.create_unix_server(
+            server, self._path, ssl=self._ssl_context, backlog=self._backlog
+        )
+
+
+class NamedPipeSite(BaseSite):
+    __slots__ = ("_path",)
+
+    def __init__(
+        self, runner: "BaseRunner", path: str, *, shutdown_timeout: float = 60.0
+    ) -> None:
+        loop = asyncio.get_event_loop()
+        if not isinstance(
+            loop, asyncio.ProactorEventLoop  # type: ignore[attr-defined]
+        ):
+            raise RuntimeError(
+                "Named Pipes only available in proactor" "loop under windows"
+            )
+        super().__init__(runner, shutdown_timeout=shutdown_timeout)
+        self._path = path
+
+    @property
+    def name(self) -> str:
+        return self._path
+
+    async def start(self) -> None:
+        await super().start()
+        loop = asyncio.get_event_loop()
+        server = self._runner.server
+        assert server is not None
+        _server = await loop.start_serving_pipe(  # type: ignore[attr-defined]
+            server, self._path
+        )
+        self._server = _server[0]
+
+
+class SockSite(BaseSite):
+    __slots__ = ("_sock", "_name")
+
+    def __init__(
+        self,
+        runner: "BaseRunner",
+        sock: socket.socket,
+        *,
+        shutdown_timeout: float = 60.0,
+        ssl_context: Optional[SSLContext] = None,
+        backlog: int = 128,
+    ) -> None:
+        super().__init__(
+            runner,
+            shutdown_timeout=shutdown_timeout,
+            ssl_context=ssl_context,
+            backlog=backlog,
+        )
+        self._sock = sock
+        scheme = "https" if self._ssl_context else "http"
+        if hasattr(socket, "AF_UNIX") and sock.family == socket.AF_UNIX:
+            name = f"{scheme}://unix:{sock.getsockname()}:"
+        else:
+            host, port = sock.getsockname()[:2]
+            name = str(URL.build(scheme=scheme, host=host, port=port))
+        self._name = name
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    async def start(self) -> None:
+        await super().start()
+        loop = asyncio.get_event_loop()
+        server = self._runner.server
+        assert server is not None
+        self._server = await loop.create_server(
+            server, sock=self._sock, ssl=self._ssl_context, backlog=self._backlog
+        )
+
+
+class BaseRunner(ABC):
+    __slots__ = ("_handle_signals", "_kwargs", "_server", "_sites")
+
+    def __init__(self, *, handle_signals: bool = False, **kwargs: Any) -> None:
+        self._handle_signals = handle_signals
+        self._kwargs = kwargs
+        self._server = None  # type: Optional[Server]
+        self._sites = []  # type: List[BaseSite]
+
+    @property
+    def server(self) -> Optional[Server]:
+        return self._server
+
+    @property
+    def addresses(self) -> List[Any]:
+        ret = []  # type: List[Any]
+        for site in self._sites:
+            server = site._server
+            if server is not None:
+                sockets = server.sockets
+                if sockets is not None:
+                    for sock in sockets:
+                        ret.append(sock.getsockname())
+        return ret
+
+    @property
+    def sites(self) -> Set[BaseSite]:
+        return set(self._sites)
+
+    async def setup(self) -> None:
+        loop = asyncio.get_event_loop()
+
+        if self._handle_signals:
+            try:
+                loop.add_signal_handler(signal.SIGINT, _raise_graceful_exit)
+                loop.add_signal_handler(signal.SIGTERM, _raise_graceful_exit)
+            except NotImplementedError:  # pragma: no cover
+                # add_signal_handler is not implemented on Windows
+                pass
+
+        self._server = await self._make_server()
+
+    @abstractmethod
+    async def shutdown(self) -> None:
+        pass  # pragma: no cover
+
+    async def cleanup(self) -> None:
+        loop = asyncio.get_event_loop()
+
+        # The loop over sites is intentional, an exception on gather()
+        # leaves self._sites in unpredictable state.
+        # The loop guaranties that a site is either deleted on success or
+        # still present on failure
+        for site in list(self._sites):
+            await site.stop()
+        await self._cleanup_server()
+        self._server = None
+        if self._handle_signals:
+            try:
+                loop.remove_signal_handler(signal.SIGINT)
+                loop.remove_signal_handler(signal.SIGTERM)
+            except NotImplementedError:  # pragma: no cover
+                # remove_signal_handler is not implemented on Windows
+                pass
+
+    @abstractmethod
+    async def _make_server(self) -> Server:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    async def _cleanup_server(self) -> None:
+        pass  # pragma: no cover
+
+    def _reg_site(self, site: BaseSite) -> None:
+        if site in self._sites:
+            raise RuntimeError(f"Site {site} is already registered in runner {self}")
+        self._sites.append(site)
+
+    def _check_site(self, site: BaseSite) -> None:
+        if site not in self._sites:
+            raise RuntimeError(f"Site {site} is not registered in runner {self}")
+
+    def _unreg_site(self, site: BaseSite) -> None:
+        if site not in self._sites:
+            raise RuntimeError(f"Site {site} is not registered in runner {self}")
+        self._sites.remove(site)
+
+
+class ServerRunner(BaseRunner):
+    """Low-level web server runner"""
+
+    __slots__ = ("_web_server",)
+
+    def __init__(
+        self, web_server: Server, *, handle_signals: bool = False, **kwargs: Any
+    ) -> None:
+        super().__init__(handle_signals=handle_signals, **kwargs)
+        self._web_server = web_server
+
+    async def shutdown(self) -> None:
+        pass
+
+    async def _make_server(self) -> Server:
+        return self._web_server
+
+    async def _cleanup_server(self) -> None:
+        pass
+
+
+class AppRunner(BaseRunner):
+    """Web Application runner"""
+
+    __slots__ = ("_app",)
+
+    def __init__(
+        self, app: Application, *, handle_signals: bool = False, **kwargs: Any
+    ) -> None:
+        super().__init__(handle_signals=handle_signals, **kwargs)
+        if not isinstance(app, Application):
+            raise TypeError(
+                "The first argument should be web.Application "
+                "instance, got {!r}".format(app)
+            )
+        self._app = app
+
+    @property
+    def app(self) -> Application:
+        return self._app
+
+    async def shutdown(self) -> None:
+        await self._app.shutdown()
+
+    async def _make_server(self) -> Server:
+        loop = asyncio.get_event_loop()
+        self._app._set_loop(loop)
+        self._app.on_startup.freeze()
+        await self._app.startup()
+        self._app.freeze()
+
+        return self._app._make_handler(loop=loop, **self._kwargs)
+
+    async def _cleanup_server(self) -> None:
+        await self._app.cleanup()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/web_server.py

@@ -0,0 +1,62 @@
+"""Low level HTTP server."""
+import asyncio
+from typing import Any, Awaitable, Callable, Dict, List, Optional  # noqa
+
+from .abc import AbstractStreamWriter
+from .helpers import get_running_loop
+from .http_parser import RawRequestMessage
+from .streams import StreamReader
+from .web_protocol import RequestHandler, _RequestFactory, _RequestHandler
+from .web_request import BaseRequest
+
+__all__ = ("Server",)
+
+
+class Server:
+    def __init__(
+        self,
+        handler: _RequestHandler,
+        *,
+        request_factory: Optional[_RequestFactory] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        **kwargs: Any
+    ) -> None:
+        self._loop = get_running_loop(loop)
+        self._connections = {}  # type: Dict[RequestHandler, asyncio.Transport]
+        self._kwargs = kwargs
+        self.requests_count = 0
+        self.request_handler = handler
+        self.request_factory = request_factory or self._make_request
+
+    @property
+    def connections(self) -> List[RequestHandler]:
+        return list(self._connections.keys())
+
+    def connection_made(
+        self, handler: RequestHandler, transport: asyncio.Transport
+    ) -> None:
+        self._connections[handler] = transport
+
+    def connection_lost(
+        self, handler: RequestHandler, exc: Optional[BaseException] = None
+    ) -> None:
+        if handler in self._connections:
+            del self._connections[handler]
+
+    def _make_request(
+        self,
+        message: RawRequestMessage,
+        payload: StreamReader,
+        protocol: RequestHandler,
+        writer: AbstractStreamWriter,
+        task: "asyncio.Task[None]",
+    ) -> BaseRequest:
+        return BaseRequest(message, payload, protocol, writer, task, self._loop)
+
+    async def shutdown(self, timeout: Optional[float] = None) -> None:
+        coros = [conn.shutdown(timeout) for conn in self._connections]
+        await asyncio.gather(*coros)
+        self._connections.clear()
+
+    def __call__(self) -> RequestHandler:
+        return RequestHandler(self, loop=self._loop, **self._kwargs)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/web_ws.py

@@ -0,0 +1,487 @@
+import asyncio
+import base64
+import binascii
+import hashlib
+import json
+from typing import Any, Iterable, Optional, Tuple, cast
+
+import async_timeout
+import attr
+from multidict import CIMultiDict
+
+from . import hdrs
+from .abc import AbstractStreamWriter
+from .helpers import call_later, set_result
+from .http import (
+    WS_CLOSED_MESSAGE,
+    WS_CLOSING_MESSAGE,
+    WS_KEY,
+    WebSocketError,
+    WebSocketReader,
+    WebSocketWriter,
+    WSCloseCode,
+    WSMessage,
+    WSMsgType as WSMsgType,
+    ws_ext_gen,
+    ws_ext_parse,
+)
+from .log import ws_logger
+from .streams import EofStream, FlowControlDataQueue
+from .typedefs import Final, JSONDecoder, JSONEncoder
+from .web_exceptions import HTTPBadRequest, HTTPException
+from .web_request import BaseRequest
+from .web_response import StreamResponse
+
+__all__ = (
+    "WebSocketResponse",
+    "WebSocketReady",
+    "WSMsgType",
+)
+
+THRESHOLD_CONNLOST_ACCESS: Final[int] = 5
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class WebSocketReady:
+    ok: bool
+    protocol: Optional[str]
+
+    def __bool__(self) -> bool:
+        return self.ok
+
+
+class WebSocketResponse(StreamResponse):
+
+    _length_check = False
+
+    def __init__(
+        self,
+        *,
+        timeout: float = 10.0,
+        receive_timeout: Optional[float] = None,
+        autoclose: bool = True,
+        autoping: bool = True,
+        heartbeat: Optional[float] = None,
+        protocols: Iterable[str] = (),
+        compress: bool = True,
+        max_msg_size: int = 4 * 1024 * 1024,
+    ) -> None:
+        super().__init__(status=101)
+        self._protocols = protocols
+        self._ws_protocol = None  # type: Optional[str]
+        self._writer = None  # type: Optional[WebSocketWriter]
+        self._reader = None  # type: Optional[FlowControlDataQueue[WSMessage]]
+        self._closed = False
+        self._closing = False
+        self._conn_lost = 0
+        self._close_code = None  # type: Optional[int]
+        self._loop = None  # type: Optional[asyncio.AbstractEventLoop]
+        self._waiting = None  # type: Optional[asyncio.Future[bool]]
+        self._exception = None  # type: Optional[BaseException]
+        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._compress = compress
+        self._max_msg_size = max_msg_size
+
+    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:
+            assert self._loop is not None
+            self._heartbeat_cb = call_later(
+                self._send_heartbeat, self._heartbeat, self._loop
+            )
+
+    def _send_heartbeat(self) -> None:
+        if self._heartbeat is not None and not self._closed:
+            assert self._loop is not None
+            # 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())  # type: ignore[union-attr]
+
+            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
+            )
+
+    def _pong_not_received(self) -> None:
+        if self._req is not None and self._req.transport is not None:
+            self._closed = True
+            self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+            self._exception = asyncio.TimeoutError()
+            self._req.transport.close()
+
+    async def prepare(self, request: BaseRequest) -> AbstractStreamWriter:
+        # make pre-check to don't hide it by do_handshake() exceptions
+        if self._payload_writer is not None:
+            return self._payload_writer
+
+        protocol, writer = self._pre_start(request)
+        payload_writer = await super().prepare(request)
+        assert payload_writer is not None
+        self._post_start(request, protocol, writer)
+        await payload_writer.drain()
+        return payload_writer
+
+    def _handshake(
+        self, request: BaseRequest
+    ) -> Tuple["CIMultiDict[str]", str, bool, bool]:
+        headers = request.headers
+        if "websocket" != headers.get(hdrs.UPGRADE, "").lower().strip():
+            raise HTTPBadRequest(
+                text=(
+                    "No WebSocket UPGRADE hdr: {}\n Can "
+                    '"Upgrade" only to "WebSocket".'
+                ).format(headers.get(hdrs.UPGRADE))
+            )
+
+        if "upgrade" not in headers.get(hdrs.CONNECTION, "").lower():
+            raise HTTPBadRequest(
+                text="No CONNECTION upgrade hdr: {}".format(
+                    headers.get(hdrs.CONNECTION)
+                )
+            )
+
+        # find common sub-protocol between client and server
+        protocol = None
+        if hdrs.SEC_WEBSOCKET_PROTOCOL in headers:
+            req_protocols = [
+                str(proto.strip())
+                for proto in headers[hdrs.SEC_WEBSOCKET_PROTOCOL].split(",")
+            ]
+
+            for proto in req_protocols:
+                if proto in self._protocols:
+                    protocol = proto
+                    break
+            else:
+                # No overlap found: Return no protocol as per spec
+                ws_logger.warning(
+                    "Client protocols %r don’t overlap server-known ones %r",
+                    req_protocols,
+                    self._protocols,
+                )
+
+        # check supported version
+        version = headers.get(hdrs.SEC_WEBSOCKET_VERSION, "")
+        if version not in ("13", "8", "7"):
+            raise HTTPBadRequest(text=f"Unsupported version: {version}")
+
+        # check client handshake for validity
+        key = headers.get(hdrs.SEC_WEBSOCKET_KEY)
+        try:
+            if not key or len(base64.b64decode(key)) != 16:
+                raise HTTPBadRequest(text=f"Handshake error: {key!r}")
+        except binascii.Error:
+            raise HTTPBadRequest(text=f"Handshake error: {key!r}") from None
+
+        accept_val = base64.b64encode(
+            hashlib.sha1(key.encode() + WS_KEY).digest()
+        ).decode()
+        response_headers = CIMultiDict(  # type: ignore[var-annotated]
+            {
+                hdrs.UPGRADE: "websocket",  # type: ignore[arg-type]
+                hdrs.CONNECTION: "upgrade",
+                hdrs.SEC_WEBSOCKET_ACCEPT: accept_val,
+            }
+        )
+
+        notakeover = False
+        compress = 0
+        if self._compress:
+            extensions = headers.get(hdrs.SEC_WEBSOCKET_EXTENSIONS)
+            # Server side always get return with no exception.
+            # If something happened, just drop compress extension
+            compress, notakeover = ws_ext_parse(extensions, isserver=True)
+            if compress:
+                enabledext = ws_ext_gen(
+                    compress=compress, isserver=True, server_notakeover=notakeover
+                )
+                response_headers[hdrs.SEC_WEBSOCKET_EXTENSIONS] = enabledext
+
+        if protocol:
+            response_headers[hdrs.SEC_WEBSOCKET_PROTOCOL] = protocol
+        return (
+            response_headers,
+            protocol,
+            compress,
+            notakeover,
+        )  # type: ignore[return-value]
+
+    def _pre_start(self, request: BaseRequest) -> Tuple[str, WebSocketWriter]:
+        self._loop = request._loop
+
+        headers, protocol, compress, notakeover = self._handshake(request)
+
+        self.set_status(101)
+        self.headers.update(headers)
+        self.force_close()
+        self._compress = compress
+        transport = request._protocol.transport
+        assert transport is not None
+        writer = WebSocketWriter(
+            request._protocol, transport, compress=compress, notakeover=notakeover
+        )
+
+        return protocol, writer
+
+    def _post_start(
+        self, request: BaseRequest, protocol: str, writer: WebSocketWriter
+    ) -> None:
+        self._ws_protocol = protocol
+        self._writer = writer
+
+        self._reset_heartbeat()
+
+        loop = self._loop
+        assert loop is not None
+        self._reader = FlowControlDataQueue(request._protocol, 2 ** 16, loop=loop)
+        request.protocol.set_parser(
+            WebSocketReader(self._reader, self._max_msg_size, compress=self._compress)
+        )
+        # disable HTTP keepalive for WebSocket
+        request.protocol.keep_alive(False)
+
+    def can_prepare(self, request: BaseRequest) -> WebSocketReady:
+        if self._writer is not None:
+            raise RuntimeError("Already started")
+        try:
+            _, protocol, _, _ = self._handshake(request)
+        except HTTPException:
+            return WebSocketReady(False, None)
+        else:
+            return WebSocketReady(True, protocol)
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    @property
+    def close_code(self) -> Optional[int]:
+        return self._close_code
+
+    @property
+    def ws_protocol(self) -> Optional[str]:
+        return self._ws_protocol
+
+    @property
+    def compress(self) -> bool:
+        return self._compress
+
+    def exception(self) -> Optional[BaseException]:
+        return self._exception
+
+    async def ping(self, message: bytes = b"") -> None:
+        if self._writer is None:
+            raise RuntimeError("Call .prepare() first")
+        await self._writer.ping(message)
+
+    async def pong(self, message: bytes = b"") -> None:
+        # unsolicited pong
+        if self._writer is None:
+            raise RuntimeError("Call .prepare() first")
+        await self._writer.pong(message)
+
+    async def send_str(self, data: str, compress: Optional[bool] = None) -> None:
+        if self._writer is None:
+            raise RuntimeError("Call .prepare() first")
+        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[bool] = None) -> None:
+        if self._writer is None:
+            raise RuntimeError("Call .prepare() first")
+        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[bool] = None,
+        *,
+        dumps: JSONEncoder = json.dumps,
+    ) -> None:
+        await self.send_str(dumps(data), compress=compress)
+
+    async def write_eof(self) -> None:  # type: ignore[override]
+        if self._eof_sent:
+            return
+        if self._payload_writer is None:
+            raise RuntimeError("Response has not been started")
+
+        await self.close()
+        self._eof_sent = True
+
+    async def close(self, *, code: int = WSCloseCode.OK, message: bytes = b"") -> bool:
+        if self._writer is None:
+            raise RuntimeError("Call .prepare() first")
+
+        self._cancel_heartbeat()
+        reader = self._reader
+        assert reader is not None
+
+        # we need to break `receive()` cycle first,
+        # `close()` may be called from different task
+        if self._waiting is not None and not self._closed:
+            reader.feed_data(WS_CLOSING_MESSAGE, 0)
+            await self._waiting
+
+        if not self._closed:
+            self._closed = True
+            try:
+                await self._writer.close(code, message)
+                writer = self._payload_writer
+                assert writer is not None
+                await writer.drain()
+            except (asyncio.CancelledError, asyncio.TimeoutError):
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                raise
+            except Exception as exc:
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                self._exception = exc
+                return True
+
+            if self._closing:
+                return True
+
+            reader = self._reader
+            assert reader is not None
+            try:
+                async with async_timeout.timeout(self._timeout):
+                    msg = await reader.read()
+            except asyncio.CancelledError:
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                raise
+            except Exception as exc:
+                self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+                self._exception = exc
+                return True
+
+            if msg.type == WSMsgType.CLOSE:
+                self._close_code = msg.data
+                return True
+
+            self._close_code = WSCloseCode.ABNORMAL_CLOSURE
+            self._exception = asyncio.TimeoutError()
+            return True
+        else:
+            return False
+
+    async def receive(self, timeout: Optional[float] = None) -> WSMessage:
+        if self._reader is None:
+            raise RuntimeError("Call .prepare() first")
+
+        loop = self._loop
+        assert loop is not None
+        while True:
+            if self._waiting is not None:
+                raise RuntimeError("Concurrent call to receive() is not allowed")
+
+            if self._closed:
+                self._conn_lost += 1
+                if self._conn_lost >= THRESHOLD_CONNLOST_ACCESS:
+                    raise RuntimeError("WebSocket connection is closed.")
+                return WS_CLOSED_MESSAGE
+            elif self._closing:
+                return WS_CLOSING_MESSAGE
+
+            try:
+                self._waiting = 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
+                    set_result(waiter, True)
+                    self._waiting = None
+            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 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(
+                "Received message {}:{!r} is not WSMsgType.TEXT".format(
+                    msg.type, msg.data
+                )
+            )
+        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 = json.loads, timeout: Optional[float] = None
+    ) -> Any:
+        data = await self.receive_str(timeout=timeout)
+        return loads(data)
+
+    async def write(self, data: bytes) -> None:
+        raise RuntimeError("Cannot call .write() for websocket")
+
+    def __aiter__(self) -> "WebSocketResponse":
+        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
+
+    def _cancel(self, exc: BaseException) -> None:
+        if self._reader is not None:
+            self._reader.set_exception(exc)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/antlr4_python3_runtime-4.9.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/antlr4_python3_runtime-4.9.3.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: antlr4-python3-runtime
+Version: 4.9.3
+Summary: ANTLR 4.9.3 runtime for Python 3.7
+Home-page: http://www.antlr.org
+Author: Eric Vergnaud, Terence Parr, Sam Harwell
+Author-email: eric.vergnaud@wanadoo.fr
+License: BSD
+Requires-Dist: typing ; python_version < "3.5"
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/antlr4_python3_runtime-4.9.3.dist-info/RECORD

@@ -0,0 +1,119 @@
+../../../bin/pygrun,sha256=MBVjE9upRGiOwLc7_ldLSW9L_KPHA_5riogxOL9AcJU,6139
+antlr4/BufferedTokenStream.py,sha256=_BwmzOH1TO6yL2yC_ZaUzkghq8wzc0UPHfI3UpnZUwM,10780
+antlr4/CommonTokenFactory.py,sha256=Tv16zg_pWD1Dv3IphsxFu8nwWdLeXYcqJ8CC5yHwjH8,2110
+antlr4/CommonTokenStream.py,sha256=NNJHXwRg2_Zn46ZhJyDxZtvZzsPWhb6JjXa7BjM45eg,2770
+antlr4/FileStream.py,sha256=-ZR_-jl_If9IIBYLINIwlQrlTSmu5k1VUKDc3ie7WR4,868
+antlr4/InputStream.py,sha256=sggjE2jEGvSgQmxFvqeeuT3aOVgcH5tS7mMybW8wKS4,2334
+antlr4/IntervalSet.py,sha256=Cd0WKhd_kYbiLYKkDNncgSM19GAuS7OaTOC4-5Yubs4,5965
+antlr4/LL1Analyzer.py,sha256=oJBvO7_S8cAlb_D4qWNxd2IlK0qP4ka-oeoDxx16CZ4,7752
+antlr4/Lexer.py,sha256=C72hqayfkympxb46AcSnhPD9kVZ0quWgboGxa6gcIcg,11542
+antlr4/ListTokenSource.py,sha256=IffLMo7YQnD_CjKryrrgNWSk0q5QSYd7puZyyUk7vOk,5356
+antlr4/Parser.py,sha256=F2Q25z0-__KHfa354KQhDu3ZOVzLFfag3s2ixJ4dl_o,22883
+antlr4/ParserInterpreter.py,sha256=-QU9kn4x3WCQ-LSA99R231HoicTqakiHZ5KM72l-hIo,7206
+antlr4/ParserRuleContext.py,sha256=wHAVdOxMAO5jkUqloTXVzn_xYnJhiHbvvuhZpth0ZF8,6762
+antlr4/PredictionContext.py,sha256=cb4KI6EGpS7sRzJ8UvPEkxphINZuWhyiZ95752g3prI,22977
+antlr4/Recognizer.py,sha256=vmKAtSjIgR9LQr5YzuK5OmPZWMJ3x69OuVZQ_FTzQHE,5383
+antlr4/RuleContext.py,sha256=GiviRv2k_al1IBgdJOEEoD0ohJaVd-_h5T_CPG_Bsmg,8099
+antlr4/StdinStream.py,sha256=MMSH4zN8T6i_nu-3_TlN-3E4nPM4b5KgK4GT6n_FUQA,303
+antlr4/Token.py,sha256=OtWCab4Ut52X_nLLAA-8x4Zl6xaF6TEN-0033uaoaEo,5206
+antlr4/TokenStreamRewriter.py,sha256=cuErQTrXwC_0kqVv3MsTWGZSm-E1Vy1yzA-3SOhKd_s,10324
+antlr4/Utils.py,sha256=Oyg8CJCRL1TrF_QSB_LLlVdWOB4loVcKOgFNT-icO7c,931
+antlr4/__init__.py,sha256=g8UGpflnlMWcAyLtihejzrgAP1Uo3b9GhwfI8QnZjtw,1125
+antlr4/__pycache__/BufferedTokenStream.cpython-38.pyc,,
+antlr4/__pycache__/CommonTokenFactory.cpython-38.pyc,,
+antlr4/__pycache__/CommonTokenStream.cpython-38.pyc,,
+antlr4/__pycache__/FileStream.cpython-38.pyc,,
+antlr4/__pycache__/InputStream.cpython-38.pyc,,
+antlr4/__pycache__/IntervalSet.cpython-38.pyc,,
+antlr4/__pycache__/LL1Analyzer.cpython-38.pyc,,
+antlr4/__pycache__/Lexer.cpython-38.pyc,,
+antlr4/__pycache__/ListTokenSource.cpython-38.pyc,,
+antlr4/__pycache__/Parser.cpython-38.pyc,,
+antlr4/__pycache__/ParserInterpreter.cpython-38.pyc,,
+antlr4/__pycache__/ParserRuleContext.cpython-38.pyc,,
+antlr4/__pycache__/PredictionContext.cpython-38.pyc,,
+antlr4/__pycache__/Recognizer.cpython-38.pyc,,
+antlr4/__pycache__/RuleContext.cpython-38.pyc,,
+antlr4/__pycache__/StdinStream.cpython-38.pyc,,
+antlr4/__pycache__/Token.cpython-38.pyc,,
+antlr4/__pycache__/TokenStreamRewriter.cpython-38.pyc,,
+antlr4/__pycache__/Utils.cpython-38.pyc,,
+antlr4/__pycache__/__init__.cpython-38.pyc,,
+antlr4/atn/ATN.py,sha256=LYE8kT-D8FpUd5fpOtyOLqvXLFkUSa83TVFowhCWAiY,5789
+antlr4/atn/ATNConfig.py,sha256=tNdIC6_GrxXllHBx3npAWyDh6KrohLZDV_XyPrydRMY,6565
+antlr4/atn/ATNConfigSet.py,sha256=qRzVsBeMqk2txjG3DrGptwF6Vb2hHC5w3umkSL0GNJw,8312
+antlr4/atn/ATNDeserializationOptions.py,sha256=lUV_bGW6mxj7t20esda5Yv-X9m-U_x1-0xaLifhXIPo,1010
+antlr4/atn/ATNDeserializer.py,sha256=aYLDDtQ-wyo3gId6A-wD1E3QmpfrPZlXxj4_IDm-mUY,22252
+antlr4/atn/ATNSimulator.py,sha256=mDc-G3GF3kSeqpfGDabUOLJ0WLVTqibxZlkvXQYmBRk,2298
+antlr4/atn/ATNState.py,sha256=NbndISWUwFDF_vuBfbTiZZ8GPHoQa6UXdqbD-yjJE7c,7663
+antlr4/atn/ATNType.py,sha256=xgv8AMVU7tc07U73_hRTm1AiZ7MvGhoaP5fTiOrrCGg,422
+antlr4/atn/LexerATNSimulator.py,sha256=kYXRwUvHptSRU8T_K9pSrGlCk9YypWeHlAcjgry1VVo,25465
+antlr4/atn/LexerAction.py,sha256=KUeJwKekBch0m1poSPskHIh-15dcKAG4lR7zlq98tzc,10014
+antlr4/atn/LexerActionExecutor.py,sha256=7rlg17THcwLsuTmh7NsLrTbRH4DTrm8qIdW9_235CEc,6420
+antlr4/atn/ParserATNSimulator.py,sha256=IKCzsDLcznROSVojU-daAygKr3svl0DmK5DhkUllASY,80365
+antlr4/atn/PredictionMode.py,sha256=i8B7MULA7v-qbXeCY_xp6sgi21kHM6kybqIrG6rSrro,22486
+antlr4/atn/SemanticContext.py,sha256=ds0TmM4qenb0LN-rl2Fp_N_xB959abN67I19EF6rs8o,10495
+antlr4/atn/Transition.py,sha256=ZAsEFpa5I_n-zxD6U-DauM5_33jFK65x3PWu6-NW0RA,8762
+antlr4/atn/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/atn/__pycache__/ATN.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNConfig.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNConfigSet.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNDeserializationOptions.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNDeserializer.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNSimulator.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNState.cpython-38.pyc,,
+antlr4/atn/__pycache__/ATNType.cpython-38.pyc,,
+antlr4/atn/__pycache__/LexerATNSimulator.cpython-38.pyc,,
+antlr4/atn/__pycache__/LexerAction.cpython-38.pyc,,
+antlr4/atn/__pycache__/LexerActionExecutor.cpython-38.pyc,,
+antlr4/atn/__pycache__/ParserATNSimulator.cpython-38.pyc,,
+antlr4/atn/__pycache__/PredictionMode.cpython-38.pyc,,
+antlr4/atn/__pycache__/SemanticContext.cpython-38.pyc,,
+antlr4/atn/__pycache__/Transition.cpython-38.pyc,,
+antlr4/atn/__pycache__/__init__.cpython-38.pyc,,
+antlr4/dfa/DFA.py,sha256=weIh0uaRfakP12mFvHo7U0tqO3GONV3-nHFkc2xk-ZE,5388
+antlr4/dfa/DFASerializer.py,sha256=1st_HO85yXLYy7gInTEnkztgA6am4CT-yReh-mazp9E,2518
+antlr4/dfa/DFAState.py,sha256=R7JwKf0GtAEs9J_MD_Y0WKcuzdt0BVX1sow-uv9yFYc,5583
+antlr4/dfa/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/dfa/__pycache__/DFA.cpython-38.pyc,,
+antlr4/dfa/__pycache__/DFASerializer.cpython-38.pyc,,
+antlr4/dfa/__pycache__/DFAState.cpython-38.pyc,,
+antlr4/dfa/__pycache__/__init__.cpython-38.pyc,,
+antlr4/error/DiagnosticErrorListener.py,sha256=EwS2D_Ox6CmvCa16NPJ9ud4QYPHmlPXt6-Wdn1h5Kg8,4430
+antlr4/error/ErrorListener.py,sha256=yP_MDguol4Cj0_pEPyNzeH3v4ZvUjW5iwDjhYTVAHbE,2722
+antlr4/error/ErrorStrategy.py,sha256=0mhzFL57ZVnjKkGrtadta93Zm3NXdF-HW10DVD07VXs,30391
+antlr4/error/Errors.py,sha256=hlKngclBfXdkDiAymhYsvh2OCXlvmHM2kTl_A1vgp-w,6759
+antlr4/error/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/error/__pycache__/DiagnosticErrorListener.cpython-38.pyc,,
+antlr4/error/__pycache__/ErrorListener.cpython-38.pyc,,
+antlr4/error/__pycache__/ErrorStrategy.cpython-38.pyc,,
+antlr4/error/__pycache__/Errors.cpython-38.pyc,,
+antlr4/error/__pycache__/__init__.cpython-38.pyc,,
+antlr4/tree/Chunk.py,sha256=oCIZjolLq9xkxtVDROEDxfUGgndcEnsDW0eUmLM7Gpk,695
+antlr4/tree/ParseTreeMatch.py,sha256=Dc6GVWSUqoIAFXUaUZqUwCUlZfTcgUbGLGzNf6QxQvE,4485
+antlr4/tree/ParseTreePattern.py,sha256=ASBNaQORh3f7f8KnFeZJC2yWFFx4uQlxvC2Y55ifhY0,2825
+antlr4/tree/ParseTreePatternMatcher.py,sha256=HtE9yi1Urr2QPLGLJDBvr0lxv6bjuj9CHl-4clahSe8,16388
+antlr4/tree/RuleTagToken.py,sha256=n4zXcmrrfsGyl91pj5ZYcc_CeKMhPrvYkUdppgMBpbY,2022
+antlr4/tree/TokenTagToken.py,sha256=S3o3DJhfzL5kpClxsKyI-Il-xvuuZQiBAIsLCKFjRHo,1576
+antlr4/tree/Tree.py,sha256=ZI7U_5IxBLm_IrnfJOtb12BCPIWyzfeZtLnhHKVVZIw,5572
+antlr4/tree/Trees.py,sha256=JtQ7cYWmKwI9TIBP6y9XIgjlNS4mYjv3ARwOfwWc5Vg,3968
+antlr4/tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+antlr4/tree/__pycache__/Chunk.cpython-38.pyc,,
+antlr4/tree/__pycache__/ParseTreeMatch.cpython-38.pyc,,
+antlr4/tree/__pycache__/ParseTreePattern.cpython-38.pyc,,
+antlr4/tree/__pycache__/ParseTreePatternMatcher.cpython-38.pyc,,
+antlr4/tree/__pycache__/RuleTagToken.cpython-38.pyc,,
+antlr4/tree/__pycache__/TokenTagToken.cpython-38.pyc,,
+antlr4/tree/__pycache__/Tree.cpython-38.pyc,,
+antlr4/tree/__pycache__/Trees.cpython-38.pyc,,
+antlr4/tree/__pycache__/__init__.cpython-38.pyc,,
+antlr4/xpath/XPath.py,sha256=O9s4-EDvLbAbYytP_bae9Z2khLl0iAtRzPAtVbuWUM4,13015
+antlr4/xpath/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/xpath/__pycache__/XPath.cpython-38.pyc,,
+antlr4/xpath/__pycache__/__init__.cpython-38.pyc,,
+antlr4_python3_runtime-4.9.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+antlr4_python3_runtime-4.9.3.dist-info/METADATA,sha256=dTjDfhCFn6_28g1-_VewZKwBUrfG-ttt11anMui4jRU,291
+antlr4_python3_runtime-4.9.3.dist-info/RECORD,,
+antlr4_python3_runtime-4.9.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+antlr4_python3_runtime-4.9.3.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+antlr4_python3_runtime-4.9.3.dist-info/top_level.txt,sha256=OsoZsh9bb30wgXb2zBUjdDwYg46MfV-RVZA6Pk8pcB0,7

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/antlr4_python3_runtime-4.9.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/antlr4_python3_runtime-4.9.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+antlr4

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/__init__.pyi

@@ -0,0 +1,484 @@
+import sys
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+# `import X as X` is required to make these public
+from . import converters as converters
+from . import exceptions as exceptions
+from . import filters as filters
+from . import setters as setters
+from . import validators as validators
+from ._version_info import VersionInfo
+
+__version__: str
+__version_info__: VersionInfo
+__title__: str
+__description__: str
+__url__: str
+__uri__: str
+__author__: str
+__email__: str
+__license__: str
+__copyright__: str
+
+_T = TypeVar("_T")
+_C = TypeVar("_C", bound=type)
+
+_EqOrderType = Union[bool, Callable[[Any], Any]]
+_ValidatorType = Callable[[Any, Attribute[_T], _T], Any]
+_ConverterType = Callable[[Any], Any]
+_FilterType = Callable[[Attribute[_T], _T], bool]
+_ReprType = Callable[[Any], str]
+_ReprArgType = Union[bool, _ReprType]
+_OnSetAttrType = Callable[[Any, Attribute[Any], Any], Any]
+_OnSetAttrArgType = Union[
+    _OnSetAttrType, List[_OnSetAttrType], setters._NoOpType
+]
+_FieldTransformer = Callable[
+    [type, List[Attribute[Any]]], List[Attribute[Any]]
+]
+_CompareWithType = Callable[[Any, Any], bool]
+# FIXME: in reality, if multiple validators are passed they must be in a list
+# or tuple, but those are invariant and so would prevent subtypes of
+# _ValidatorType from working when passed in a list or tuple.
+_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
+
+# _make --
+
+NOTHING: object
+
+# NOTE: Factory lies about its return type to make this possible:
+# `x: List[int] # = Factory(list)`
+# Work around mypy issue #4554 in the common case by using an overload.
+if sys.version_info >= (3, 8):
+    from typing import Literal
+    @overload
+    def Factory(factory: Callable[[], _T]) -> _T: ...
+    @overload
+    def Factory(
+        factory: Callable[[Any], _T],
+        takes_self: Literal[True],
+    ) -> _T: ...
+    @overload
+    def Factory(
+        factory: Callable[[], _T],
+        takes_self: Literal[False],
+    ) -> _T: ...
+
+else:
+    @overload
+    def Factory(factory: Callable[[], _T]) -> _T: ...
+    @overload
+    def Factory(
+        factory: Union[Callable[[Any], _T], Callable[[], _T]],
+        takes_self: bool = ...,
+    ) -> _T: ...
+
+# Static type inference support via __dataclass_transform__ implemented as per:
+# https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md
+# This annotation must be applied to all overloads of "define" and "attrs"
+#
+# NOTE: This is a typing construct and does not exist at runtime.  Extensions
+# wrapping attrs decorators should declare a separate __dataclass_transform__
+# signature in the extension module using the specification linked above to
+# provide pyright support.
+def __dataclass_transform__(
+    *,
+    eq_default: bool = True,
+    order_default: bool = False,
+    kw_only_default: bool = False,
+    field_descriptors: Tuple[Union[type, Callable[..., Any]], ...] = (()),
+) -> Callable[[_T], _T]: ...
+
+class Attribute(Generic[_T]):
+    name: str
+    default: Optional[_T]
+    validator: Optional[_ValidatorType[_T]]
+    repr: _ReprArgType
+    cmp: _EqOrderType
+    eq: _EqOrderType
+    order: _EqOrderType
+    hash: Optional[bool]
+    init: bool
+    converter: Optional[_ConverterType]
+    metadata: Dict[Any, Any]
+    type: Optional[Type[_T]]
+    kw_only: bool
+    on_setattr: _OnSetAttrType
+    def evolve(self, **changes: Any) -> "Attribute[Any]": ...
+
+# NOTE: We had several choices for the annotation to use for type arg:
+# 1) Type[_T]
+#   - Pros: Handles simple cases correctly
+#   - Cons: Might produce less informative errors in the case of conflicting
+#     TypeVars e.g. `attr.ib(default='bad', type=int)`
+# 2) Callable[..., _T]
+#   - Pros: Better error messages than #1 for conflicting TypeVars
+#   - Cons: Terrible error messages for validator checks.
+#   e.g. attr.ib(type=int, validator=validate_str)
+#        -> error: Cannot infer function type argument
+# 3) type (and do all of the work in the mypy plugin)
+#   - Pros: Simple here, and we could customize the plugin with our own errors.
+#   - Cons: Would need to write mypy plugin code to handle all the cases.
+# We chose option #1.
+
+# `attr` lies about its return type to make the following possible:
+#     attr()    -> Any
+#     attr(8)   -> int
+#     attr(validator=<some callable>)  -> Whatever the callable expects.
+# This makes this type of assignments possible:
+#     x: int = attr(8)
+#
+# This form catches explicit None or no default but with no other arguments
+# returns Any.
+@overload
+def attrib(
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: None = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def attrib(
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def attrib(
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def attrib(
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: object = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: None = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the
+# other arguments.
+@overload
+def field(
+    *,
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def field(
+    *,
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def field(
+    *,
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: _ReprArgType = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    converter: Optional[_ConverterType] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+) -> Any: ...
+@overload
+@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
+def attrs(
+    maybe_cls: _C,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    auto_detect: bool = ...,
+    collect_by_mro: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> _C: ...
+@overload
+@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
+def attrs(
+    maybe_cls: None = ...,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    auto_detect: bool = ...,
+    collect_by_mro: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> Callable[[_C], _C]: ...
+@overload
+@__dataclass_transform__(field_descriptors=(attrib, field))
+def define(
+    maybe_cls: _C,
+    *,
+    these: Optional[Dict[str, Any]] = ...,
+    repr: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> _C: ...
+@overload
+@__dataclass_transform__(field_descriptors=(attrib, field))
+def define(
+    maybe_cls: None = ...,
+    *,
+    these: Optional[Dict[str, Any]] = ...,
+    repr: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[bool] = ...,
+    order: Optional[bool] = ...,
+    auto_detect: bool = ...,
+    getstate_setstate: Optional[bool] = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+    match_args: bool = ...,
+) -> Callable[[_C], _C]: ...
+
+mutable = define
+frozen = define  # they differ only in their defaults
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+class _Fields(Tuple[Attribute[Any], ...]):
+    def __getattr__(self, name: str) -> Attribute[Any]: ...
+
+def fields(cls: type) -> _Fields: ...
+def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ...
+def validate(inst: Any) -> None: ...
+def resolve_types(
+    cls: _C,
+    globalns: Optional[Dict[str, Any]] = ...,
+    localns: Optional[Dict[str, Any]] = ...,
+    attribs: Optional[List[Attribute[Any]]] = ...,
+) -> _C: ...
+
+# TODO: add support for returning a proper attrs class from the mypy plugin
+# we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
+# [attr.ib()])` is valid
+def make_class(
+    name: str,
+    attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+    bases: Tuple[type, ...] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: Optional[_EqOrderType] = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+    auto_exc: bool = ...,
+    eq: Optional[_EqOrderType] = ...,
+    order: Optional[_EqOrderType] = ...,
+    collect_by_mro: bool = ...,
+    on_setattr: Optional[_OnSetAttrArgType] = ...,
+    field_transformer: Optional[_FieldTransformer] = ...,
+) -> type: ...
+
+# _funcs --
+
+# TODO: add support for returning TypedDict from the mypy plugin
+# FIXME: asdict/astuple do not honor their factory args. Waiting on one of
+# these:
+# https://github.com/python/mypy/issues/4236
+# https://github.com/python/typing/issues/253
+# XXX: remember to fix attrs.asdict/astuple too!
+def asdict(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    dict_factory: Type[Mapping[Any, Any]] = ...,
+    retain_collection_types: bool = ...,
+    value_serializer: Optional[
+        Callable[[type, Attribute[Any], Any], Any]
+    ] = ...,
+    tuple_keys: Optional[bool] = ...,
+) -> Dict[str, Any]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType[Any]] = ...,
+    tuple_factory: Type[Sequence[Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Tuple[Any, ...]: ...
+def has(cls: type) -> bool: ...
+def assoc(inst: _T, **changes: Any) -> _T: ...
+def evolve(inst: _T, **changes: Any) -> _T: ...
+
+# _config --
+
+def set_run_validators(run: bool) -> None: ...
+def get_run_validators() -> bool: ...
+
+# aliases --
+
+s = attributes = attrs
+ib = attr = attrib
+dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_cmp.pyi

@@ -0,0 +1,13 @@
+from typing import Type
+
+from . import _CompareWithType
+
+def cmp_using(
+    eq: Optional[_CompareWithType],
+    lt: Optional[_CompareWithType],
+    le: Optional[_CompareWithType],
+    gt: Optional[_CompareWithType],
+    ge: Optional[_CompareWithType],
+    require_same_type: bool,
+    class_name: str,
+) -> Type: ...

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_config.py

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: MIT
+
+from __future__ import absolute_import, division, print_function
+
+
+__all__ = ["set_run_validators", "get_run_validators"]
+
+_run_validators = True
+
+
+def set_run_validators(run):
+    """
+    Set whether or not validators are run.  By default, they are run.
+
+    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
+        moved to new ``attrs`` namespace. Use `attrs.validators.set_disabled()`
+        instead.
+    """
+    if not isinstance(run, bool):
+        raise TypeError("'run' must be bool.")
+    global _run_validators
+    _run_validators = run
+
+
+def get_run_validators():
+    """
+    Return whether or not validators are run.
+
+    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
+        moved to new ``attrs`` namespace. Use `attrs.validators.get_disabled()`
+        instead.
+    """
+    return _run_validators

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/converters.py

@@ -0,0 +1,155 @@
+# SPDX-License-Identifier: MIT
+
+"""
+Commonly useful converters.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from ._compat import PY2
+from ._make import NOTHING, Factory, pipe
+
+
+if not PY2:
+    import inspect
+    import typing
+
+
+__all__ = [
+    "default_if_none",
+    "optional",
+    "pipe",
+    "to_bool",
+]
+
+
+def optional(converter):
+    """
+    A converter that allows an attribute to be optional. An optional attribute
+    is one which can be set to ``None``.
+
+    Type annotations will be inferred from the wrapped converter's, if it
+    has any.
+
+    :param callable converter: the converter that is used for non-``None``
+        values.
+
+    .. versionadded:: 17.1.0
+    """
+
+    def optional_converter(val):
+        if val is None:
+            return None
+        return converter(val)
+
+    if not PY2:
+        sig = None
+        try:
+            sig = inspect.signature(converter)
+        except (ValueError, TypeError):  # inspect failed
+            pass
+        if sig:
+            params = list(sig.parameters.values())
+            if params and params[0].annotation is not inspect.Parameter.empty:
+                optional_converter.__annotations__["val"] = typing.Optional[
+                    params[0].annotation
+                ]
+            if sig.return_annotation is not inspect.Signature.empty:
+                optional_converter.__annotations__["return"] = typing.Optional[
+                    sig.return_annotation
+                ]
+
+    return optional_converter
+
+
+def default_if_none(default=NOTHING, factory=None):
+    """
+    A converter that allows to replace ``None`` values by *default* or the
+    result of *factory*.
+
+    :param default: Value to be used if ``None`` is passed. Passing an instance
+       of `attrs.Factory` is supported, however the ``takes_self`` option
+       is *not*.
+    :param callable factory: A callable that takes no parameters whose result
+       is used if ``None`` is passed.
+
+    :raises TypeError: If **neither** *default* or *factory* is passed.
+    :raises TypeError: If **both** *default* and *factory* are passed.
+    :raises ValueError: If an instance of `attrs.Factory` is passed with
+       ``takes_self=True``.
+
+    .. versionadded:: 18.2.0
+    """
+    if default is NOTHING and factory is None:
+        raise TypeError("Must pass either `default` or `factory`.")
+
+    if default is not NOTHING and factory is not None:
+        raise TypeError(
+            "Must pass either `default` or `factory` but not both."
+        )
+
+    if factory is not None:
+        default = Factory(factory)
+
+    if isinstance(default, Factory):
+        if default.takes_self:
+            raise ValueError(
+                "`takes_self` is not supported by default_if_none."
+            )
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default.factory()
+
+    else:
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default
+
+    return default_if_none_converter
+
+
+def to_bool(val):
+    """
+    Convert "boolean" strings (e.g., from env. vars.) to real booleans.
+
+    Values mapping to :code:`True`:
+
+    - :code:`True`
+    - :code:`"true"` / :code:`"t"`
+    - :code:`"yes"` / :code:`"y"`
+    - :code:`"on"`
+    - :code:`"1"`
+    - :code:`1`
+
+    Values mapping to :code:`False`:
+
+    - :code:`False`
+    - :code:`"false"` / :code:`"f"`
+    - :code:`"no"` / :code:`"n"`
+    - :code:`"off"`
+    - :code:`"0"`
+    - :code:`0`
+
+    :raises ValueError: for any other value.
+
+    .. versionadded:: 21.3.0
+    """
+    if isinstance(val, str):
+        val = val.lower()
+    truthy = {True, "true", "t", "yes", "y", "on", "1", 1}
+    falsy = {False, "false", "f", "no", "n", "off", "0", 0}
+    try:
+        if val in truthy:
+            return True
+        if val in falsy:
+            return False
+    except TypeError:
+        # Raised when "val" is not hashable (e.g., lists)
+        pass
+    raise ValueError("Cannot convert value to bool: {}".format(val))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/exceptions.pyi

@@ -0,0 +1,17 @@
+from typing import Any
+
+class FrozenError(AttributeError):
+    msg: str = ...
+
+class FrozenInstanceError(FrozenError): ...
+class FrozenAttributeError(FrozenError): ...
+class AttrsAttributeNotFoundError(ValueError): ...
+class NotAnAttrsClassError(ValueError): ...
+class DefaultAlreadySetError(RuntimeError): ...
+class UnannotatedAttributeError(RuntimeError): ...
+class PythonTooOldError(RuntimeError): ...
+
+class NotCallableError(TypeError):
+    msg: str = ...
+    value: Any = ...
+    def __init__(self, msg: str, value: Any) -> None: ...

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/__init__.py

@@ -0,0 +1,40 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+"""Initialize the object database module"""
+
+import sys
+import os
+
+#{ Initialization
+
+
+def _init_externals():
+    """Initialize external projects by putting them into the path"""
+    for module in ('smmap',):
+        if 'PYOXIDIZER' not in os.environ:
+            sys.path.append(os.path.join(os.path.dirname(__file__), 'ext', module))
+
+        try:
+            __import__(module)
+        except ImportError as e:
+            raise ImportError("'%s' could not be imported, assure it is located in your PYTHONPATH" % module) from e
+        # END verify import
+    # END handel imports
+
+#} END initialization
+
+_init_externals()
+
+__author__ = "Sebastian Thiel"
+__contact__ = "byronimo@gmail.com"
+__homepage__ = "https://github.com/gitpython-developers/gitdb"
+version_info = (4, 0, 9)
+__version__ = '.'.join(str(i) for i in version_info)
+
+
+# default imports
+from gitdb.base import *
+from gitdb.db import *
+from gitdb.stream import *

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/base.py

@@ -0,0 +1,315 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+"""Module with basic data structures - they are designed to be lightweight and fast"""
+from gitdb.util import bin_to_hex
+
+from gitdb.fun import (
+    type_id_to_type_map,
+    type_to_type_id_map
+)
+
+__all__ = ('OInfo', 'OPackInfo', 'ODeltaPackInfo',
+           'OStream', 'OPackStream', 'ODeltaPackStream',
+           'IStream', 'InvalidOInfo', 'InvalidOStream')
+
+#{ ODB Bases
+
+
+class OInfo(tuple):
+
+    """Carries information about an object in an ODB, providing information
+    about the binary sha of the object, the type_string as well as the uncompressed size
+    in bytes.
+
+    It can be accessed using tuple notation and using attribute access notation::
+
+        assert dbi[0] == dbi.binsha
+        assert dbi[1] == dbi.type
+        assert dbi[2] == dbi.size
+
+    The type is designed to be as lightweight as possible."""
+    __slots__ = tuple()
+
+    def __new__(cls, sha, type, size):
+        return tuple.__new__(cls, (sha, type, size))
+
+    def __init__(self, *args):
+        tuple.__init__(self)
+
+    #{ Interface
+    @property
+    def binsha(self):
+        """:return: our sha as binary, 20 bytes"""
+        return self[0]
+
+    @property
+    def hexsha(self):
+        """:return: our sha, hex encoded, 40 bytes"""
+        return bin_to_hex(self[0])
+
+    @property
+    def type(self):
+        return self[1]
+
+    @property
+    def type_id(self):
+        return type_to_type_id_map[self[1]]
+
+    @property
+    def size(self):
+        return self[2]
+    #} END interface
+
+
+class OPackInfo(tuple):
+
+    """As OInfo, but provides a type_id property to retrieve the numerical type id, and
+    does not include a sha.
+
+    Additionally, the pack_offset is the absolute offset into the packfile at which
+    all object information is located. The data_offset property points to the absolute
+    location in the pack at which that actual data stream can be found."""
+    __slots__ = tuple()
+
+    def __new__(cls, packoffset, type, size):
+        return tuple.__new__(cls, (packoffset, type, size))
+
+    def __init__(self, *args):
+        tuple.__init__(self)
+
+    #{ Interface
+
+    @property
+    def pack_offset(self):
+        return self[0]
+
+    @property
+    def type(self):
+        return type_id_to_type_map[self[1]]
+
+    @property
+    def type_id(self):
+        return self[1]
+
+    @property
+    def size(self):
+        return self[2]
+
+    #} END interface
+
+
+class ODeltaPackInfo(OPackInfo):
+
+    """Adds delta specific information,
+    Either the 20 byte sha which points to some object in the database,
+    or the negative offset from the pack_offset, so that pack_offset - delta_info yields
+    the pack offset of the base object"""
+    __slots__ = tuple()
+
+    def __new__(cls, packoffset, type, size, delta_info):
+        return tuple.__new__(cls, (packoffset, type, size, delta_info))
+
+    #{ Interface
+    @property
+    def delta_info(self):
+        return self[3]
+    #} END interface
+
+
+class OStream(OInfo):
+
+    """Base for object streams retrieved from the database, providing additional
+    information about the stream.
+    Generally, ODB streams are read-only as objects are immutable"""
+    __slots__ = tuple()
+
+    def __new__(cls, sha, type, size, stream, *args, **kwargs):
+        """Helps with the initialization of subclasses"""
+        return tuple.__new__(cls, (sha, type, size, stream))
+
+    def __init__(self, *args, **kwargs):
+        tuple.__init__(self)
+
+    #{ Stream Reader Interface
+
+    def read(self, size=-1):
+        return self[3].read(size)
+
+    @property
+    def stream(self):
+        return self[3]
+
+    #} END stream reader interface
+
+
+class ODeltaStream(OStream):
+
+    """Uses size info of its stream, delaying reads"""
+
+    def __new__(cls, sha, type, size, stream, *args, **kwargs):
+        """Helps with the initialization of subclasses"""
+        return tuple.__new__(cls, (sha, type, size, stream))
+
+    #{ Stream Reader Interface
+
+    @property
+    def size(self):
+        return self[3].size
+
+    #} END stream reader interface
+
+
+class OPackStream(OPackInfo):
+
+    """Next to pack object information, a stream outputting an undeltified base object
+    is provided"""
+    __slots__ = tuple()
+
+    def __new__(cls, packoffset, type, size, stream, *args):
+        """Helps with the initialization of subclasses"""
+        return tuple.__new__(cls, (packoffset, type, size, stream))
+
+    #{ Stream Reader Interface
+    def read(self, size=-1):
+        return self[3].read(size)
+
+    @property
+    def stream(self):
+        return self[3]
+    #} END stream reader interface
+
+
+class ODeltaPackStream(ODeltaPackInfo):
+
+    """Provides a stream outputting the uncompressed offset delta information"""
+    __slots__ = tuple()
+
+    def __new__(cls, packoffset, type, size, delta_info, stream):
+        return tuple.__new__(cls, (packoffset, type, size, delta_info, stream))
+
+    #{ Stream Reader Interface
+    def read(self, size=-1):
+        return self[4].read(size)
+
+    @property
+    def stream(self):
+        return self[4]
+    #} END stream reader interface
+
+
+class IStream(list):
+
+    """Represents an input content stream to be fed into the ODB. It is mutable to allow
+    the ODB to record information about the operations outcome right in this instance.
+
+    It provides interfaces for the OStream and a StreamReader to allow the instance
+    to blend in without prior conversion.
+
+    The only method your content stream must support is 'read'"""
+    __slots__ = tuple()
+
+    def __new__(cls, type, size, stream, sha=None):
+        return list.__new__(cls, (sha, type, size, stream, None))
+
+    def __init__(self, type, size, stream, sha=None):
+        list.__init__(self, (sha, type, size, stream, None))
+
+    #{ Interface
+    @property
+    def hexsha(self):
+        """:return: our sha, hex encoded, 40 bytes"""
+        return bin_to_hex(self[0])
+
+    def _error(self):
+        """:return: the error that occurred when processing the stream, or None"""
+        return self[4]
+
+    def _set_error(self, exc):
+        """Set this input stream to the given exc, may be None to reset the error"""
+        self[4] = exc
+
+    error = property(_error, _set_error)
+
+    #} END interface
+
+    #{ Stream Reader Interface
+
+    def read(self, size=-1):
+        """Implements a simple stream reader interface, passing the read call on
+            to our internal stream"""
+        return self[3].read(size)
+
+    #} END stream reader interface
+
+    #{  interface
+
+    def _set_binsha(self, binsha):
+        self[0] = binsha
+
+    def _binsha(self):
+        return self[0]
+
+    binsha = property(_binsha, _set_binsha)
+
+    def _type(self):
+        return self[1]
+
+    def _set_type(self, type):
+        self[1] = type
+
+    type = property(_type, _set_type)
+
+    def _size(self):
+        return self[2]
+
+    def _set_size(self, size):
+        self[2] = size
+
+    size = property(_size, _set_size)
+
+    def _stream(self):
+        return self[3]
+
+    def _set_stream(self, stream):
+        self[3] = stream
+
+    stream = property(_stream, _set_stream)
+
+    #} END odb info interface
+
+
+class InvalidOInfo(tuple):
+
+    """Carries information about a sha identifying an object which is invalid in
+    the queried database. The exception attribute provides more information about
+    the cause of the issue"""
+    __slots__ = tuple()
+
+    def __new__(cls, sha, exc):
+        return tuple.__new__(cls, (sha, exc))
+
+    def __init__(self, sha, exc):
+        tuple.__init__(self, (sha, exc))
+
+    @property
+    def binsha(self):
+        return self[0]
+
+    @property
+    def hexsha(self):
+        return bin_to_hex(self[0])
+
+    @property
+    def error(self):
+        """:return: exception instance explaining the failure"""
+        return self[1]
+
+
+class InvalidOStream(InvalidOInfo):
+
+    """Carries information about an invalid ODB stream"""
+    __slots__ = tuple()
+
+#} END ODB Bases

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/const.py

@@ -0,0 +1,4 @@
+BYTE_SPACE = b' '
+NULL_BYTE = b'\0'
+NULL_HEX_SHA = "0" * 40
+NULL_BIN_SHA = NULL_BYTE * 20

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/exc.py

@@ -0,0 +1,46 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+"""Module with common exceptions"""
+from gitdb.util import to_hex_sha
+
+
+class ODBError(Exception):
+    """All errors thrown by the object database"""
+
+
+class InvalidDBRoot(ODBError):
+    """Thrown if an object database cannot be initialized at the given path"""
+
+
+class BadObject(ODBError):
+    """The object with the given SHA does not exist. Instantiate with the
+    failed sha"""
+
+    def __str__(self):
+        return "BadObject: %s" % to_hex_sha(self.args[0])
+
+
+class BadName(ODBError):
+    """A name provided to rev_parse wasn't understood"""
+
+    def __str__(self):
+        return "Ref '%s' did not resolve to an object" % self.args[0]
+
+
+class ParseError(ODBError):
+    """Thrown if the parsing of a file failed due to an invalid format"""
+
+
+class AmbiguousObjectName(ODBError):
+    """Thrown if a possibly shortened name does not uniquely represent a single object
+    in the database"""
+
+
+class BadObjectType(ODBError):
+    """The object had an unsupported type"""
+
+
+class UnsupportedOperation(ODBError):
+    """Thrown if the given operation cannot be supported by the object database"""

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/fun.py

@@ -0,0 +1,704 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+"""Contains basic c-functions which usually contain performance critical code
+Keeping this code separate from the beginning makes it easier to out-source
+it into c later, if required"""
+
+import zlib
+from gitdb.util import byte_ord
+decompressobj = zlib.decompressobj
+
+import mmap
+from itertools import islice
+from functools import reduce
+
+from gitdb.const import NULL_BYTE, BYTE_SPACE
+from gitdb.utils.encoding import force_text
+from gitdb.typ import (
+    str_blob_type,
+    str_commit_type,
+    str_tree_type,
+    str_tag_type,
+)
+
+from io import StringIO
+
+# INVARIANTS
+OFS_DELTA = 6
+REF_DELTA = 7
+delta_types = (OFS_DELTA, REF_DELTA)
+
+type_id_to_type_map = {
+    0: b'',             # EXT 1
+    1: str_commit_type,
+    2: str_tree_type,
+    3: str_blob_type,
+    4: str_tag_type,
+    5: b'',             # EXT 2
+    OFS_DELTA: "OFS_DELTA",    # OFFSET DELTA
+    REF_DELTA: "REF_DELTA"     # REFERENCE DELTA
+}
+
+type_to_type_id_map = {
+    str_commit_type: 1,
+    str_tree_type: 2,
+    str_blob_type: 3,
+    str_tag_type: 4,
+    "OFS_DELTA": OFS_DELTA,
+    "REF_DELTA": REF_DELTA,
+}
+
+# used when dealing with larger streams
+chunk_size = 1000 * mmap.PAGESIZE
+
+__all__ = ('is_loose_object', 'loose_object_header_info', 'msb_size', 'pack_object_header_info',
+           'write_object', 'loose_object_header', 'stream_copy', 'apply_delta_data',
+           'is_equal_canonical_sha', 'connect_deltas', 'DeltaChunkList', 'create_pack_object_header')
+
+
+#{ Structures
+
+def _set_delta_rbound(d, size):
+    """Truncate the given delta to the given size
+    :param size: size relative to our target offset, may not be 0, must be smaller or equal
+        to our size
+    :return: d"""
+    d.ts = size
+
+    # NOTE: data is truncated automatically when applying the delta
+    # MUST NOT DO THIS HERE
+    return d
+
+
+def _move_delta_lbound(d, bytes):
+    """Move the delta by the given amount of bytes, reducing its size so that its
+    right bound stays static
+    :param bytes: amount of bytes to move, must be smaller than delta size
+    :return: d"""
+    if bytes == 0:
+        return
+
+    d.to += bytes
+    d.so += bytes
+    d.ts -= bytes
+    if d.data is not None:
+        d.data = d.data[bytes:]
+    # END handle data
+
+    return d
+
+
+def delta_duplicate(src):
+    return DeltaChunk(src.to, src.ts, src.so, src.data)
+
+
+def delta_chunk_apply(dc, bbuf, write):
+    """Apply own data to the target buffer
+    :param bbuf: buffer providing source bytes for copy operations
+    :param write: write method to call with data to write"""
+    if dc.data is None:
+        # COPY DATA FROM SOURCE
+        write(bbuf[dc.so:dc.so + dc.ts])
+    else:
+        # APPEND DATA
+        # whats faster: if + 4 function calls or just a write with a slice ?
+        # Considering data can be larger than 127 bytes now, it should be worth it
+        if dc.ts < len(dc.data):
+            write(dc.data[:dc.ts])
+        else:
+            write(dc.data)
+        # END handle truncation
+    # END handle chunk mode
+
+
+class DeltaChunk(object):
+
+    """Represents a piece of a delta, it can either add new data, or copy existing
+    one from a source buffer"""
+    __slots__ = (
+        'to',       # start offset in the target buffer in bytes
+                    'ts',       # size of this chunk in the target buffer in bytes
+                    'so',       # start offset in the source buffer in bytes or None
+                    'data',     # chunk of bytes to be added to the target buffer,
+                                # DeltaChunkList to use as base, or None
+    )
+
+    def __init__(self, to, ts, so, data):
+        self.to = to
+        self.ts = ts
+        self.so = so
+        self.data = data
+
+    def __repr__(self):
+        return "DeltaChunk(%i, %i, %s, %s)" % (self.to, self.ts, self.so, self.data or "")
+
+    #{ Interface
+
+    def rbound(self):
+        return self.to + self.ts
+
+    def has_data(self):
+        """:return: True if the instance has data to add to the target stream"""
+        return self.data is not None
+
+    #} END interface
+
+
+def _closest_index(dcl, absofs):
+    """:return: index at which the given absofs should be inserted. The index points
+    to the DeltaChunk with a target buffer absofs that equals or is greater than
+    absofs.
+    **Note:** global method for performance only, it belongs to DeltaChunkList"""
+    lo = 0
+    hi = len(dcl)
+    while lo < hi:
+        mid = (lo + hi) / 2
+        dc = dcl[mid]
+        if dc.to > absofs:
+            hi = mid
+        elif dc.rbound() > absofs or dc.to == absofs:
+            return mid
+        else:
+            lo = mid + 1
+        # END handle bound
+    # END for each delta absofs
+    return len(dcl) - 1
+
+
+def delta_list_apply(dcl, bbuf, write):
+    """Apply the chain's changes and write the final result using the passed
+    write function.
+    :param bbuf: base buffer containing the base of all deltas contained in this
+        list. It will only be used if the chunk in question does not have a base
+        chain.
+    :param write: function taking a string of bytes to write to the output"""
+    for dc in dcl:
+        delta_chunk_apply(dc, bbuf, write)
+    # END for each dc
+
+
+def delta_list_slice(dcl, absofs, size, ndcl):
+    """:return: Subsection of this  list at the given absolute  offset, with the given
+        size in bytes.
+    :return: None"""
+    cdi = _closest_index(dcl, absofs)   # delta start index
+    cd = dcl[cdi]
+    slen = len(dcl)
+    lappend = ndcl.append
+
+    if cd.to != absofs:
+        tcd = DeltaChunk(cd.to, cd.ts, cd.so, cd.data)
+        _move_delta_lbound(tcd, absofs - cd.to)
+        tcd.ts = min(tcd.ts, size)
+        lappend(tcd)
+        size -= tcd.ts
+        cdi += 1
+    # END lbound overlap handling
+
+    while cdi < slen and size:
+        # are we larger than the current block
+        cd = dcl[cdi]
+        if cd.ts <= size:
+            lappend(DeltaChunk(cd.to, cd.ts, cd.so, cd.data))
+            size -= cd.ts
+        else:
+            tcd = DeltaChunk(cd.to, cd.ts, cd.so, cd.data)
+            tcd.ts = size
+            lappend(tcd)
+            size -= tcd.ts
+            break
+        # END hadle size
+        cdi += 1
+    # END for each chunk
+
+
+class DeltaChunkList(list):
+
+    """List with special functionality to deal with DeltaChunks.
+    There are two types of lists we represent. The one was created bottom-up, working
+    towards the latest delta, the other kind was created top-down, working from the
+    latest delta down to the earliest ancestor. This attribute is queryable
+    after all processing with is_reversed."""
+
+    __slots__ = tuple()
+
+    def rbound(self):
+        """:return: rightmost extend in bytes, absolute"""
+        if len(self) == 0:
+            return 0
+        return self[-1].rbound()
+
+    def lbound(self):
+        """:return: leftmost byte at which this chunklist starts"""
+        if len(self) == 0:
+            return 0
+        return self[0].to
+
+    def size(self):
+        """:return: size of bytes as measured by our delta chunks"""
+        return self.rbound() - self.lbound()
+
+    def apply(self, bbuf, write):
+        """Only used by public clients, internally we only use the global routines
+        for performance"""
+        return delta_list_apply(self, bbuf, write)
+
+    def compress(self):
+        """Alter the list to reduce the amount of nodes. Currently we concatenate
+        add-chunks
+        :return: self"""
+        slen = len(self)
+        if slen < 2:
+            return self
+        i = 0
+
+        first_data_index = None
+        while i < slen:
+            dc = self[i]
+            i += 1
+            if dc.data is None:
+                if first_data_index is not None and i - 2 - first_data_index > 1:
+                    # if first_data_index is not None:
+                    nd = StringIO()                     # new data
+                    so = self[first_data_index].to      # start offset in target buffer
+                    for x in range(first_data_index, i - 1):
+                        xdc = self[x]
+                        nd.write(xdc.data[:xdc.ts])
+                    # END collect data
+
+                    del(self[first_data_index:i - 1])
+                    buf = nd.getvalue()
+                    self.insert(first_data_index, DeltaChunk(so, len(buf), 0, buf))
+
+                    slen = len(self)
+                    i = first_data_index + 1
+
+                # END concatenate data
+                first_data_index = None
+                continue
+            # END skip non-data chunks
+
+            if first_data_index is None:
+                first_data_index = i - 1
+        # END iterate list
+
+        # if slen_orig != len(self):
+        #   print "INFO: Reduced delta list len to %f %% of former size" % ((float(len(self)) / slen_orig) * 100)
+        return self
+
+    def check_integrity(self, target_size=-1):
+        """Verify the list has non-overlapping chunks only, and the total size matches
+        target_size
+        :param target_size: if not -1, the total size of the chain must be target_size
+        :raise AssertionError: if the size doen't match"""
+        if target_size > -1:
+            assert self[-1].rbound() == target_size
+            assert reduce(lambda x, y: x + y, (d.ts for d in self), 0) == target_size
+        # END target size verification
+
+        if len(self) < 2:
+            return
+
+        # check data
+        for dc in self:
+            assert dc.ts > 0
+            if dc.has_data():
+                assert len(dc.data) >= dc.ts
+        # END for each dc
+
+        left = islice(self, 0, len(self) - 1)
+        right = iter(self)
+        right.next()
+        # this is very pythonic - we might have just use index based access here,
+        # but this could actually be faster
+        for lft, rgt in zip(left, right):
+            assert lft.rbound() == rgt.to
+            assert lft.to + lft.ts == rgt.to
+        # END for each pair
+
+
+class TopdownDeltaChunkList(DeltaChunkList):
+
+    """Represents a list which is generated by feeding its ancestor streams one by
+    one"""
+    __slots__ = tuple()
+
+    def connect_with_next_base(self, bdcl):
+        """Connect this chain with the next level of our base delta chunklist.
+        The goal in this game is to mark as many of our chunks rigid, hence they
+        cannot be changed by any of the upcoming bases anymore. Once all our
+        chunks are marked like that, we can stop all processing
+        :param bdcl: data chunk list being one of our bases. They must be fed in
+            consequtively and in order, towards the earliest ancestor delta
+        :return: True if processing was done. Use it to abort processing of
+            remaining streams if False is returned"""
+        nfc = 0                             # number of frozen chunks
+        dci = 0                             # delta chunk index
+        slen = len(self)                    # len of self
+        ccl = list()                        # temporary list
+        while dci < slen:
+            dc = self[dci]
+            dci += 1
+
+            # all add-chunks which are already topmost don't need additional processing
+            if dc.data is not None:
+                nfc += 1
+                continue
+            # END skip add chunks
+
+            # copy chunks
+            # integrate the portion of the base list into ourselves. Lists
+            # dont support efficient insertion ( just one at a time ), but for now
+            # we live with it. Internally, its all just a 32/64bit pointer, and
+            # the portions of moved memory should be smallish. Maybe we just rebuild
+            # ourselves in order to reduce the amount of insertions ...
+            del(ccl[:])
+            delta_list_slice(bdcl, dc.so, dc.ts, ccl)
+
+            # move the target bounds into place to match with our chunk
+            ofs = dc.to - dc.so
+            for cdc in ccl:
+                cdc.to += ofs
+            # END update target bounds
+
+            if len(ccl) == 1:
+                self[dci - 1] = ccl[0]
+            else:
+                # maybe try to compute the expenses here, and pick the right algorithm
+                # It would normally be faster than copying everything physically though
+                # TODO: Use a deque here, and decide by the index whether to extend
+                # or extend left !
+                post_dci = self[dci:]
+                del(self[dci - 1:])           # include deletion of dc
+                self.extend(ccl)
+                self.extend(post_dci)
+
+                slen = len(self)
+                dci += len(ccl) - 1           # deleted dc, added rest
+
+            # END handle chunk replacement
+        # END for each chunk
+
+        if nfc == slen:
+            return False
+        # END handle completeness
+        return True
+
+
+#} END structures
+
+#{ Routines
+
+def is_loose_object(m):
+    """
+    :return: True the file contained in memory map m appears to be a loose object.
+        Only the first two bytes are needed"""
+    b0, b1 = map(ord, m[:2])
+    word = (b0 << 8) + b1
+    return b0 == 0x78 and (word % 31) == 0
+
+
+def loose_object_header_info(m):
+    """
+    :return: tuple(type_string, uncompressed_size_in_bytes) the type string of the
+        object as well as its uncompressed size in bytes.
+    :param m: memory map from which to read the compressed object data"""
+    decompress_size = 8192      # is used in cgit as well
+    hdr = decompressobj().decompress(m, decompress_size)
+    type_name, size = hdr[:hdr.find(NULL_BYTE)].split(BYTE_SPACE)
+
+    return type_name, int(size)
+
+
+def pack_object_header_info(data):
+    """
+    :return: tuple(type_id, uncompressed_size_in_bytes, byte_offset)
+        The type_id should be interpreted according to the ``type_id_to_type_map`` map
+        The byte-offset specifies the start of the actual zlib compressed datastream
+    :param m: random-access memory, like a string or memory map"""
+    c = byte_ord(data[0])           # first byte
+    i = 1                           # next char to read
+    type_id = (c >> 4) & 7          # numeric type
+    size = c & 15                   # starting size
+    s = 4                           # starting bit-shift size
+    while c & 0x80:
+        c = byte_ord(data[i])
+        i += 1
+        size += (c & 0x7f) << s
+        s += 7
+    # END character loop
+    # end performance at expense of maintenance ...
+    return (type_id, size, i)
+
+
+def create_pack_object_header(obj_type, obj_size):
+    """
+    :return: string defining the pack header comprised of the object type
+        and its incompressed size in bytes
+
+    :param obj_type: pack type_id of the object
+    :param obj_size: uncompressed size in bytes of the following object stream"""
+    c = 0       # 1 byte
+    hdr = bytearray()  # output string
+
+    c = (obj_type << 4) | (obj_size & 0xf)
+    obj_size >>= 4
+    while obj_size:
+        hdr.append(c | 0x80)
+        c = obj_size & 0x7f
+        obj_size >>= 7
+    # END until size is consumed
+    hdr.append(c)
+    # end handle interpreter
+    return hdr
+
+
+def msb_size(data, offset=0):
+    """
+    :return: tuple(read_bytes, size) read the msb size from the given random
+        access data starting at the given byte offset"""
+    size = 0
+    i = 0
+    l = len(data)
+    hit_msb = False
+    while i < l:
+        c = data[i + offset]
+        size |= (c & 0x7f) << i * 7
+        i += 1
+        if not c & 0x80:
+            hit_msb = True
+            break
+        # END check msb bit
+    # END while in range
+    # end performance ...
+    if not hit_msb:
+        raise AssertionError("Could not find terminating MSB byte in data stream")
+    return i + offset, size
+
+
+def loose_object_header(type, size):
+    """
+    :return: bytes representing the loose object header, which is immediately
+        followed by the content stream of size 'size'"""
+    return ('%s %i\0' % (force_text(type), size)).encode('ascii')
+
+
+def write_object(type, size, read, write, chunk_size=chunk_size):
+    """
+    Write the object as identified by type, size and source_stream into the
+    target_stream
+
+    :param type: type string of the object
+    :param size: amount of bytes to write from source_stream
+    :param read: read method of a stream providing the content data
+    :param write: write method of the output stream
+    :param close_target_stream: if True, the target stream will be closed when
+        the routine exits, even if an error is thrown
+    :return: The actual amount of bytes written to stream, which includes the header and a trailing newline"""
+    tbw = 0                                             # total num bytes written
+
+    # WRITE HEADER: type SP size NULL
+    tbw += write(loose_object_header(type, size))
+    tbw += stream_copy(read, write, size, chunk_size)
+
+    return tbw
+
+
+def stream_copy(read, write, size, chunk_size):
+    """
+    Copy a stream up to size bytes using the provided read and write methods,
+    in chunks of chunk_size
+
+    **Note:** its much like stream_copy utility, but operates just using methods"""
+    dbw = 0                                             # num data bytes written
+
+    # WRITE ALL DATA UP TO SIZE
+    while True:
+        cs = min(chunk_size, size - dbw)
+        # NOTE: not all write methods return the amount of written bytes, like
+        # mmap.write. Its bad, but we just deal with it ... perhaps its not
+        # even less efficient
+        # data_len = write(read(cs))
+        # dbw += data_len
+        data = read(cs)
+        data_len = len(data)
+        dbw += data_len
+        write(data)
+        if data_len < cs or dbw == size:
+            break
+        # END check for stream end
+    # END duplicate data
+    return dbw
+
+
+def connect_deltas(dstreams):
+    """
+    Read the condensed delta chunk information from dstream and merge its information
+        into a list of existing delta chunks
+
+    :param dstreams: iterable of delta stream objects, the delta to be applied last
+        comes first, then all its ancestors in order
+    :return: DeltaChunkList, containing all operations to apply"""
+    tdcl = None                         # topmost dcl
+
+    dcl = tdcl = TopdownDeltaChunkList()
+    for dsi, ds in enumerate(dstreams):
+        # print "Stream", dsi
+        db = ds.read()
+        delta_buf_size = ds.size
+
+        # read header
+        i, base_size = msb_size(db)
+        i, target_size = msb_size(db, i)
+
+        # interpret opcodes
+        tbw = 0                     # amount of target bytes written
+        while i < delta_buf_size:
+            c = ord(db[i])
+            i += 1
+            if c & 0x80:
+                cp_off, cp_size = 0, 0
+                if (c & 0x01):
+                    cp_off = ord(db[i])
+                    i += 1
+                if (c & 0x02):
+                    cp_off |= (ord(db[i]) << 8)
+                    i += 1
+                if (c & 0x04):
+                    cp_off |= (ord(db[i]) << 16)
+                    i += 1
+                if (c & 0x08):
+                    cp_off |= (ord(db[i]) << 24)
+                    i += 1
+                if (c & 0x10):
+                    cp_size = ord(db[i])
+                    i += 1
+                if (c & 0x20):
+                    cp_size |= (ord(db[i]) << 8)
+                    i += 1
+                if (c & 0x40):
+                    cp_size |= (ord(db[i]) << 16)
+                    i += 1
+
+                if not cp_size:
+                    cp_size = 0x10000
+
+                rbound = cp_off + cp_size
+                if (rbound < cp_size or
+                        rbound > base_size):
+                    break
+
+                dcl.append(DeltaChunk(tbw, cp_size, cp_off, None))
+                tbw += cp_size
+            elif c:
+                # NOTE: in C, the data chunks should probably be concatenated here.
+                # In python, we do it as a post-process
+                dcl.append(DeltaChunk(tbw, c, 0, db[i:i + c]))
+                i += c
+                tbw += c
+            else:
+                raise ValueError("unexpected delta opcode 0")
+            # END handle command byte
+        # END while processing delta data
+
+        dcl.compress()
+
+        # merge the lists !
+        if dsi > 0:
+            if not tdcl.connect_with_next_base(dcl):
+                break
+        # END handle merge
+
+        # prepare next base
+        dcl = DeltaChunkList()
+    # END for each delta stream
+
+    return tdcl
+
+
+def apply_delta_data(src_buf, src_buf_size, delta_buf, delta_buf_size, write):
+    """
+    Apply data from a delta buffer using a source buffer to the target file
+
+    :param src_buf: random access data from which the delta was created
+    :param src_buf_size: size of the source buffer in bytes
+    :param delta_buf_size: size fo the delta buffer in bytes
+    :param delta_buf: random access delta data
+    :param write: write method taking a chunk of bytes
+
+    **Note:** transcribed to python from the similar routine in patch-delta.c"""
+    i = 0
+    db = delta_buf
+    while i < delta_buf_size:
+        c = db[i]
+        i += 1
+        if c & 0x80:
+            cp_off, cp_size = 0, 0
+            if (c & 0x01):
+                cp_off = db[i]
+                i += 1
+            if (c & 0x02):
+                cp_off |= (db[i] << 8)
+                i += 1
+            if (c & 0x04):
+                cp_off |= (db[i] << 16)
+                i += 1
+            if (c & 0x08):
+                cp_off |= (db[i] << 24)
+                i += 1
+            if (c & 0x10):
+                cp_size = db[i]
+                i += 1
+            if (c & 0x20):
+                cp_size |= (db[i] << 8)
+                i += 1
+            if (c & 0x40):
+                cp_size |= (db[i] << 16)
+                i += 1
+
+            if not cp_size:
+                cp_size = 0x10000
+
+            rbound = cp_off + cp_size
+            if (rbound < cp_size or
+                    rbound > src_buf_size):
+                break
+            write(src_buf[cp_off:cp_off + cp_size])
+        elif c:
+            write(db[i:i + c])
+            i += c
+        else:
+            raise ValueError("unexpected delta opcode 0")
+        # END handle command byte
+    # END while processing delta data
+
+    # yes, lets use the exact same error message that git uses :)
+    assert i == delta_buf_size, "delta replay has gone wild"
+
+
+def is_equal_canonical_sha(canonical_length, match, sha1):
+    """
+    :return: True if the given lhs and rhs 20 byte binary shas
+        The comparison will take the canonical_length of the match sha into account,
+        hence the comparison will only use the last 4 bytes for uneven canonical representations
+    :param match: less than 20 byte sha
+    :param sha1: 20 byte sha"""
+    binary_length = canonical_length // 2
+    if match[:binary_length] != sha1[:binary_length]:
+        return False
+
+    if canonical_length - binary_length and \
+            (byte_ord(match[-1]) ^ byte_ord(sha1[len(match) - 1])) & 0xf0:
+        return False
+    # END handle uneven canonnical length
+    return True
+
+#} END routines
+
+
+try:
+    from gitdb_speedups._perf import connect_deltas
+except ImportError:
+    pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/pack.py

@@ -0,0 +1,1031 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+"""Contains PackIndexFile and PackFile implementations"""
+import zlib
+
+from gitdb.exc import (
+    BadObject,
+    AmbiguousObjectName,
+    UnsupportedOperation,
+    ParseError
+)
+
+from gitdb.util import (
+    mman,
+    LazyMixin,
+    unpack_from,
+    bin_to_hex,
+    byte_ord,
+)
+
+from gitdb.fun import (
+    create_pack_object_header,
+    pack_object_header_info,
+    is_equal_canonical_sha,
+    type_id_to_type_map,
+    write_object,
+    stream_copy,
+    chunk_size,
+    delta_types,
+    OFS_DELTA,
+    REF_DELTA,
+    msb_size
+)
+
+try:
+    from gitdb_speedups._perf import PackIndexFile_sha_to_index
+except ImportError:
+    pass
+# END try c module
+
+from gitdb.base import (      # Amazing !
+    OInfo,
+    OStream,
+    OPackInfo,
+    OPackStream,
+    ODeltaStream,
+    ODeltaPackInfo,
+    ODeltaPackStream,
+)
+
+from gitdb.stream import (
+    DecompressMemMapReader,
+    DeltaApplyReader,
+    Sha1Writer,
+    NullStream,
+    FlexibleSha1Writer
+)
+
+from struct import pack
+from binascii import crc32
+
+from gitdb.const import NULL_BYTE
+
+import tempfile
+import array
+import os
+import sys
+
+__all__ = ('PackIndexFile', 'PackFile', 'PackEntity')
+
+
+#{ Utilities
+
+def pack_object_at(cursor, offset, as_stream):
+    """
+    :return: Tuple(abs_data_offset, PackInfo|PackStream)
+        an object of the correct type according to the type_id  of the object.
+        If as_stream is True, the object will contain a stream, allowing  the
+        data to be read decompressed.
+    :param data: random accessible data containing all required information
+    :parma offset: offset in to the data at which the object information is located
+    :param as_stream: if True, a stream object will be returned that can read
+        the data, otherwise you receive an info object only"""
+    data = cursor.use_region(offset).buffer()
+    type_id, uncomp_size, data_rela_offset = pack_object_header_info(data)
+    total_rela_offset = None                # set later, actual offset until data stream begins
+    delta_info = None
+
+    # OFFSET DELTA
+    if type_id == OFS_DELTA:
+        i = data_rela_offset
+        c = byte_ord(data[i])
+        i += 1
+        delta_offset = c & 0x7f
+        while c & 0x80:
+            c = byte_ord(data[i])
+            i += 1
+            delta_offset += 1
+            delta_offset = (delta_offset << 7) + (c & 0x7f)
+        # END character loop
+        delta_info = delta_offset
+        total_rela_offset = i
+    # REF DELTA
+    elif type_id == REF_DELTA:
+        total_rela_offset = data_rela_offset + 20
+        delta_info = data[data_rela_offset:total_rela_offset]
+    # BASE OBJECT
+    else:
+        # assume its a base object
+        total_rela_offset = data_rela_offset
+    # END handle type id
+    abs_data_offset = offset + total_rela_offset
+    if as_stream:
+        stream = DecompressMemMapReader(data[total_rela_offset:], False, uncomp_size)
+        if delta_info is None:
+            return abs_data_offset, OPackStream(offset, type_id, uncomp_size, stream)
+        else:
+            return abs_data_offset, ODeltaPackStream(offset, type_id, uncomp_size, delta_info, stream)
+    else:
+        if delta_info is None:
+            return abs_data_offset, OPackInfo(offset, type_id, uncomp_size)
+        else:
+            return abs_data_offset, ODeltaPackInfo(offset, type_id, uncomp_size, delta_info)
+        # END handle info
+    # END handle stream
+
+
+def write_stream_to_pack(read, write, zstream, base_crc=None):
+    """Copy a stream as read from read function, zip it, and write the result.
+    Count the number of written bytes and return it
+    :param base_crc: if not None, the crc will be the base for all compressed data
+        we consecutively write and generate a crc32 from. If None, no crc will be generated
+    :return: tuple(no bytes read, no bytes written, crc32) crc might be 0 if base_crc
+        was false"""
+    br = 0      # bytes read
+    bw = 0      # bytes written
+    want_crc = base_crc is not None
+    crc = 0
+    if want_crc:
+        crc = base_crc
+    # END initialize crc
+
+    while True:
+        chunk = read(chunk_size)
+        br += len(chunk)
+        compressed = zstream.compress(chunk)
+        bw += len(compressed)
+        write(compressed)           # cannot assume return value
+
+        if want_crc:
+            crc = crc32(compressed, crc)
+        # END handle crc
+
+        if len(chunk) != chunk_size:
+            break
+    # END copy loop
+
+    compressed = zstream.flush()
+    bw += len(compressed)
+    write(compressed)
+    if want_crc:
+        crc = crc32(compressed, crc)
+    # END handle crc
+
+    return (br, bw, crc)
+
+
+#} END utilities
+
+
+class IndexWriter(object):
+
+    """Utility to cache index information, allowing to write all information later
+    in one go to the given stream
+    **Note:** currently only writes v2 indices"""
+    __slots__ = '_objs'
+
+    def __init__(self):
+        self._objs = list()
+
+    def append(self, binsha, crc, offset):
+        """Append one piece of object information"""
+        self._objs.append((binsha, crc, offset))
+
+    def write(self, pack_sha, write):
+        """Write the index file using the given write method
+        :param pack_sha: binary sha over the whole pack that we index
+        :return: sha1 binary sha over all index file contents"""
+        # sort for sha1 hash
+        self._objs.sort(key=lambda o: o[0])
+
+        sha_writer = FlexibleSha1Writer(write)
+        sha_write = sha_writer.write
+        sha_write(PackIndexFile.index_v2_signature)
+        sha_write(pack(">L", PackIndexFile.index_version_default))
+
+        # fanout
+        tmplist = list((0,) * 256)                                # fanout or list with 64 bit offsets
+        for t in self._objs:
+            tmplist[byte_ord(t[0][0])] += 1
+        # END prepare fanout
+        for i in range(255):
+            v = tmplist[i]
+            sha_write(pack('>L', v))
+            tmplist[i + 1] += v
+        # END write each fanout entry
+        sha_write(pack('>L', tmplist[255]))
+
+        # sha1 ordered
+        # save calls, that is push them into c
+        sha_write(b''.join(t[0] for t in self._objs))
+
+        # crc32
+        for t in self._objs:
+            sha_write(pack('>L', t[1] & 0xffffffff))
+        # END for each crc
+
+        tmplist = list()
+        # offset 32
+        for t in self._objs:
+            ofs = t[2]
+            if ofs > 0x7fffffff:
+                tmplist.append(ofs)
+                ofs = 0x80000000 + len(tmplist) - 1
+            # END hande 64 bit offsets
+            sha_write(pack('>L', ofs & 0xffffffff))
+        # END for each offset
+
+        # offset 64
+        for ofs in tmplist:
+            sha_write(pack(">Q", ofs))
+        # END for each offset
+
+        # trailer
+        assert(len(pack_sha) == 20)
+        sha_write(pack_sha)
+        sha = sha_writer.sha(as_hex=False)
+        write(sha)
+        return sha
+
+
+class PackIndexFile(LazyMixin):
+
+    """A pack index provides offsets into the corresponding pack, allowing to find
+    locations for offsets faster."""
+
+    # Dont use slots as we dynamically bind functions for each version, need a dict for this
+    # The slots you see here are just to keep track of our instance variables
+    # __slots__ = ('_indexpath', '_fanout_table', '_cursor', '_version',
+    #               '_sha_list_offset', '_crc_list_offset', '_pack_offset', '_pack_64_offset')
+
+    # used in v2 indices
+    _sha_list_offset = 8 + 1024
+    index_v2_signature = b'\xfftOc'
+    index_version_default = 2
+
+    def __init__(self, indexpath):
+        super(PackIndexFile, self).__init__()
+        self._indexpath = indexpath
+
+    def close(self):
+        mman.force_map_handle_removal_win(self._indexpath)
+        self._cursor = None
+        
+    def _set_cache_(self, attr):
+        if attr == "_packfile_checksum":
+            self._packfile_checksum = self._cursor.map()[-40:-20]
+        elif attr == "_packfile_checksum":
+            self._packfile_checksum = self._cursor.map()[-20:]
+        elif attr == "_cursor":
+            # Note: We don't lock the file when reading as we cannot be sure
+            # that we can actually write to the location - it could be a read-only
+            # alternate for instance
+            self._cursor = mman.make_cursor(self._indexpath).use_region()
+            # We will assume that the index will always fully fit into memory !
+            if mman.window_size() > 0 and self._cursor.file_size() > mman.window_size():
+                raise AssertionError("The index file at %s is too large to fit into a mapped window (%i > %i). This is a limitation of the implementation" % (
+                    self._indexpath, self._cursor.file_size(), mman.window_size()))
+            # END assert window size
+        else:
+            # now its time to initialize everything - if we are here, someone wants
+            # to access the fanout table or related properties
+
+            # CHECK VERSION
+            mmap = self._cursor.map()
+            self._version = (mmap[:4] == self.index_v2_signature and 2) or 1
+            if self._version == 2:
+                version_id = unpack_from(">L", mmap, 4)[0]
+                assert version_id == self._version, "Unsupported index version: %i" % version_id
+            # END assert version
+
+            # SETUP FUNCTIONS
+            # setup our functions according to the actual version
+            for fname in ('entry', 'offset', 'sha', 'crc'):
+                setattr(self, fname, getattr(self, "_%s_v%i" % (fname, self._version)))
+            # END for each function to initialize
+
+            # INITIALIZE DATA
+            # byte offset is 8 if version is 2, 0 otherwise
+            self._initialize()
+        # END handle attributes
+
+    #{ Access V1
+
+    def _entry_v1(self, i):
+        """:return: tuple(offset, binsha, 0)"""
+        return unpack_from(">L20s", self._cursor.map(), 1024 + i * 24) + (0, )
+
+    def _offset_v1(self, i):
+        """see ``_offset_v2``"""
+        return unpack_from(">L", self._cursor.map(), 1024 + i * 24)[0]
+
+    def _sha_v1(self, i):
+        """see ``_sha_v2``"""
+        base = 1024 + (i * 24) + 4
+        return self._cursor.map()[base:base + 20]
+
+    def _crc_v1(self, i):
+        """unsupported"""
+        return 0
+
+    #} END access V1
+
+    #{ Access V2
+    def _entry_v2(self, i):
+        """:return: tuple(offset, binsha, crc)"""
+        return (self._offset_v2(i), self._sha_v2(i), self._crc_v2(i))
+
+    def _offset_v2(self, i):
+        """:return: 32 or 64 byte offset into pack files. 64 byte offsets will only
+            be returned if the pack is larger than 4 GiB, or 2^32"""
+        offset = unpack_from(">L", self._cursor.map(), self._pack_offset + i * 4)[0]
+
+        # if the high-bit is set, this indicates that we have to lookup the offset
+        # in the 64 bit region of the file. The current offset ( lower 31 bits )
+        # are the index into it
+        if offset & 0x80000000:
+            offset = unpack_from(">Q", self._cursor.map(), self._pack_64_offset + (offset & ~0x80000000) * 8)[0]
+        # END handle 64 bit offset
+
+        return offset
+
+    def _sha_v2(self, i):
+        """:return: sha at the given index of this file index instance"""
+        base = self._sha_list_offset + i * 20
+        return self._cursor.map()[base:base + 20]
+
+    def _crc_v2(self, i):
+        """:return: 4 bytes crc for the object at index i"""
+        return unpack_from(">L", self._cursor.map(), self._crc_list_offset + i * 4)[0]
+
+    #} END access V2
+
+    #{ Initialization
+
+    def _initialize(self):
+        """initialize base data"""
+        self._fanout_table = self._read_fanout((self._version == 2) * 8)
+
+        if self._version == 2:
+            self._crc_list_offset = self._sha_list_offset + self.size() * 20
+            self._pack_offset = self._crc_list_offset + self.size() * 4
+            self._pack_64_offset = self._pack_offset + self.size() * 4
+        # END setup base
+
+    def _read_fanout(self, byte_offset):
+        """Generate a fanout table from our data"""
+        d = self._cursor.map()
+        out = list()
+        append = out.append
+        for i in range(256):
+            append(unpack_from('>L', d, byte_offset + i * 4)[0])
+        # END for each entry
+        return out
+
+    #} END initialization
+
+    #{ Properties
+    def version(self):
+        return self._version
+
+    def size(self):
+        """:return: amount of objects referred to by this index"""
+        return self._fanout_table[255]
+
+    def path(self):
+        """:return: path to the packindexfile"""
+        return self._indexpath
+
+    def packfile_checksum(self):
+        """:return: 20 byte sha representing the sha1 hash of the pack file"""
+        return self._cursor.map()[-40:-20]
+
+    def indexfile_checksum(self):
+        """:return: 20 byte sha representing the sha1 hash of this index file"""
+        return self._cursor.map()[-20:]
+
+    def offsets(self):
+        """:return: sequence of all offsets in the order in which they were written
+
+        **Note:** return value can be random accessed, but may be immmutable"""
+        if self._version == 2:
+            # read stream to array, convert to tuple
+            a = array.array('I')    # 4 byte unsigned int, long are 8 byte on 64 bit it appears
+            a.frombytes(self._cursor.map()[self._pack_offset:self._pack_64_offset])
+
+            # networkbyteorder to something array likes more
+            if sys.byteorder == 'little':
+                a.byteswap()
+            return a
+        else:
+            return tuple(self.offset(index) for index in range(self.size()))
+        # END handle version
+
+    def sha_to_index(self, sha):
+        """
+        :return: index usable with the ``offset`` or ``entry`` method, or None
+            if the sha was not found in this pack index
+        :param sha: 20 byte sha to lookup"""
+        first_byte = byte_ord(sha[0])
+        get_sha = self.sha
+        lo = 0                  # lower index, the left bound of the bisection
+        if first_byte != 0:
+            lo = self._fanout_table[first_byte - 1]
+        hi = self._fanout_table[first_byte]     # the upper, right bound of the bisection
+
+        # bisect until we have the sha
+        while lo < hi:
+            mid = (lo + hi) // 2
+            mid_sha = get_sha(mid)
+            if sha < mid_sha:
+                hi = mid
+            elif sha == mid_sha:
+                return mid
+            else:
+                lo = mid + 1
+            # END handle midpoint
+        # END bisect
+        return None
+
+    def partial_sha_to_index(self, partial_bin_sha, canonical_length):
+        """
+        :return: index as in `sha_to_index` or None if the sha was not found in this
+            index file
+        :param partial_bin_sha: an at least two bytes of a partial binary sha as bytes
+        :param canonical_length: length of the original hexadecimal representation of the
+            given partial binary sha
+        :raise AmbiguousObjectName:"""
+        if len(partial_bin_sha) < 2:
+            raise ValueError("Require at least 2 bytes of partial sha")
+
+        assert isinstance(partial_bin_sha, bytes), "partial_bin_sha must be bytes"
+        first_byte = byte_ord(partial_bin_sha[0])
+
+        get_sha = self.sha
+        lo = 0                  # lower index, the left bound of the bisection
+        if first_byte != 0:
+            lo = self._fanout_table[first_byte - 1]
+        hi = self._fanout_table[first_byte]     # the upper, right bound of the bisection
+
+        # fill the partial to full 20 bytes
+        filled_sha = partial_bin_sha + NULL_BYTE * (20 - len(partial_bin_sha))
+
+        # find lowest
+        while lo < hi:
+            mid = (lo + hi) // 2
+            mid_sha = get_sha(mid)
+            if filled_sha < mid_sha:
+                hi = mid
+            elif filled_sha == mid_sha:
+                # perfect match
+                lo = mid
+                break
+            else:
+                lo = mid + 1
+            # END handle midpoint
+        # END bisect
+
+        if lo < self.size():
+            cur_sha = get_sha(lo)
+            if is_equal_canonical_sha(canonical_length, partial_bin_sha, cur_sha):
+                next_sha = None
+                if lo + 1 < self.size():
+                    next_sha = get_sha(lo + 1)
+                if next_sha and next_sha == cur_sha:
+                    raise AmbiguousObjectName(partial_bin_sha)
+                return lo
+            # END if we have a match
+        # END if we found something
+        return None
+
+    if 'PackIndexFile_sha_to_index' in globals():
+        # NOTE: Its just about 25% faster, the major bottleneck might be the attr
+        # accesses
+        def sha_to_index(self, sha):
+            return PackIndexFile_sha_to_index(self, sha)
+    # END redefine heavy-hitter with c version
+
+    #} END properties
+
+
+class PackFile(LazyMixin):
+
+    """A pack is a file written according to the Version 2 for git packs
+
+    As we currently use memory maps, it could be assumed that the maximum size of
+    packs therefor is 32 bit on 32 bit systems. On 64 bit systems, this should be
+    fine though.
+
+    **Note:** at some point, this might be implemented using streams as well, or
+    streams are an alternate path in the case memory maps cannot be created
+    for some reason - one clearly doesn't want to read 10GB at once in that
+    case"""
+
+    __slots__ = ('_packpath', '_cursor', '_size', '_version')
+    pack_signature = 0x5041434b     # 'PACK'
+    pack_version_default = 2
+
+    # offset into our data at which the first object starts
+    first_object_offset = 3 * 4       # header bytes
+    footer_size = 20                # final sha
+
+    def __init__(self, packpath):
+        self._packpath = packpath
+
+    def close(self):
+        mman.force_map_handle_removal_win(self._packpath)
+        self._cursor = None
+        
+    def _set_cache_(self, attr):
+        # we fill the whole cache, whichever attribute gets queried first
+        self._cursor = mman.make_cursor(self._packpath).use_region()
+
+        # read the header information
+        type_id, self._version, self._size = unpack_from(">LLL", self._cursor.map(), 0)
+
+        # TODO: figure out whether we should better keep the lock, or maybe
+        # add a .keep file instead ?
+        if type_id != self.pack_signature:
+            raise ParseError("Invalid pack signature: %i" % type_id)
+
+    def _iter_objects(self, start_offset, as_stream=True):
+        """Handle the actual iteration of objects within this pack"""
+        c = self._cursor
+        content_size = c.file_size() - self.footer_size
+        cur_offset = start_offset or self.first_object_offset
+
+        null = NullStream()
+        while cur_offset < content_size:
+            data_offset, ostream = pack_object_at(c, cur_offset, True)
+            # scrub the stream to the end - this decompresses the object, but yields
+            # the amount of compressed bytes we need to get to the next offset
+
+            stream_copy(ostream.read, null.write, ostream.size, chunk_size)
+            assert ostream.stream._br == ostream.size
+            cur_offset += (data_offset - ostream.pack_offset) + ostream.stream.compressed_bytes_read()
+
+            # if a stream is requested, reset it beforehand
+            # Otherwise return the Stream object directly, its derived from the
+            # info object
+            if as_stream:
+                ostream.stream.seek(0)
+            yield ostream
+        # END until we have read everything
+
+    #{ Pack Information
+
+    def size(self):
+        """:return: The amount of objects stored in this pack"""
+        return self._size
+
+    def version(self):
+        """:return: the version of this pack"""
+        return self._version
+
+    def data(self):
+        """
+        :return: read-only data of this pack. It provides random access and usually
+            is a memory map.
+        :note: This method is unsafe as it returns a window into a file which might be larger than than the actual window size"""
+        # can use map as we are starting at offset 0. Otherwise we would have to use buffer()
+        return self._cursor.use_region().map()
+
+    def checksum(self):
+        """:return: 20 byte sha1 hash on all object sha's contained in this file"""
+        return self._cursor.use_region(self._cursor.file_size() - 20).buffer()[:]
+
+    def path(self):
+        """:return: path to the packfile"""
+        return self._packpath
+    #} END pack information
+
+    #{ Pack Specific
+
+    def collect_streams(self, offset):
+        """
+        :return: list of pack streams which are required to build the object
+            at the given offset. The first entry of the list is the object at offset,
+            the last one is either a full object, or a REF_Delta stream. The latter
+            type needs its reference object to be locked up in an ODB to form a valid
+            delta chain.
+            If the object at offset is no delta, the size of the list is 1.
+        :param offset: specifies the first byte of the object within this pack"""
+        out = list()
+        c = self._cursor
+        while True:
+            ostream = pack_object_at(c, offset, True)[1]
+            out.append(ostream)
+            if ostream.type_id == OFS_DELTA:
+                offset = ostream.pack_offset - ostream.delta_info
+            else:
+                # the only thing we can lookup are OFFSET deltas. Everything
+                # else is either an object, or a ref delta, in the latter
+                # case someone else has to find it
+                break
+            # END handle type
+        # END while chaining streams
+        return out
+
+    #} END pack specific
+
+    #{ Read-Database like Interface
+
+    def info(self, offset):
+        """Retrieve information about the object at the given file-absolute offset
+
+        :param offset: byte offset
+        :return: OPackInfo instance, the actual type differs depending on the type_id attribute"""
+        return pack_object_at(self._cursor, offset or self.first_object_offset, False)[1]
+
+    def stream(self, offset):
+        """Retrieve an object at the given file-relative offset as stream along with its information
+
+        :param offset: byte offset
+        :return: OPackStream instance, the actual type differs depending on the type_id attribute"""
+        return pack_object_at(self._cursor, offset or self.first_object_offset, True)[1]
+
+    def stream_iter(self, start_offset=0):
+        """
+        :return: iterator yielding OPackStream compatible instances, allowing
+            to access the data in the pack directly.
+        :param start_offset: offset to the first object to iterate. If 0, iteration
+            starts at the very first object in the pack.
+
+        **Note:** Iterating a pack directly is costly as the datastream has to be decompressed
+        to determine the bounds between the objects"""
+        return self._iter_objects(start_offset, as_stream=True)
+
+    #} END Read-Database like Interface
+
+
+class PackEntity(LazyMixin):
+
+    """Combines the PackIndexFile and the PackFile into one, allowing the
+    actual objects to be resolved and iterated"""
+
+    __slots__ = ('_index',           # our index file
+                 '_pack',            # our pack file
+                 '_offset_map'       # on demand dict mapping one offset to the next consecutive one
+                 )
+
+    IndexFileCls = PackIndexFile
+    PackFileCls = PackFile
+
+    def __init__(self, pack_or_index_path):
+        """Initialize ourselves with the path to the respective pack or index file"""
+        basename, ext = os.path.splitext(pack_or_index_path)
+        self._index = self.IndexFileCls("%s.idx" % basename)            # PackIndexFile instance
+        self._pack = self.PackFileCls("%s.pack" % basename)         # corresponding PackFile instance
+
+    def close(self):
+        self._index.close()
+        self._pack.close()
+
+    def _set_cache_(self, attr):
+        # currently this can only be _offset_map
+        # TODO: make this a simple sorted offset array which can be bisected
+        # to find the respective entry, from which we can take a +1 easily
+        # This might be slower, but should also be much lighter in memory !
+        offsets_sorted = sorted(self._index.offsets())
+        last_offset = len(self._pack.data()) - self._pack.footer_size
+        assert offsets_sorted, "Cannot handle empty indices"
+
+        offset_map = None
+        if len(offsets_sorted) == 1:
+            offset_map = {offsets_sorted[0]: last_offset}
+        else:
+            iter_offsets = iter(offsets_sorted)
+            iter_offsets_plus_one = iter(offsets_sorted)
+            next(iter_offsets_plus_one)
+            consecutive = zip(iter_offsets, iter_offsets_plus_one)
+
+            offset_map = dict(consecutive)
+
+            # the last offset is not yet set
+            offset_map[offsets_sorted[-1]] = last_offset
+        # END handle offset amount
+        self._offset_map = offset_map
+
+    def _sha_to_index(self, sha):
+        """:return: index for the given sha, or raise"""
+        index = self._index.sha_to_index(sha)
+        if index is None:
+            raise BadObject(sha)
+        return index
+
+    def _iter_objects(self, as_stream):
+        """Iterate over all objects in our index and yield their OInfo or OStream instences"""
+        _sha = self._index.sha
+        _object = self._object
+        for index in range(self._index.size()):
+            yield _object(_sha(index), as_stream, index)
+        # END for each index
+
+    def _object(self, sha, as_stream, index=-1):
+        """:return: OInfo or OStream object providing information about the given sha
+        :param index: if not -1, its assumed to be the sha's index in the IndexFile"""
+        # its a little bit redundant here, but it needs to be efficient
+        if index < 0:
+            index = self._sha_to_index(sha)
+        if sha is None:
+            sha = self._index.sha(index)
+        # END assure sha is present ( in output )
+        offset = self._index.offset(index)
+        type_id, uncomp_size, data_rela_offset = pack_object_header_info(self._pack._cursor.use_region(offset).buffer())
+        if as_stream:
+            if type_id not in delta_types:
+                packstream = self._pack.stream(offset)
+                return OStream(sha, packstream.type, packstream.size, packstream.stream)
+            # END handle non-deltas
+
+            # produce a delta stream containing all info
+            # To prevent it from applying the deltas when querying the size,
+            # we extract it from the delta stream ourselves
+            streams = self.collect_streams_at_offset(offset)
+            dstream = DeltaApplyReader.new(streams)
+
+            return ODeltaStream(sha, dstream.type, None, dstream)
+        else:
+            if type_id not in delta_types:
+                return OInfo(sha, type_id_to_type_map[type_id], uncomp_size)
+            # END handle non-deltas
+
+            # deltas are a little tougher - unpack the first bytes to obtain
+            # the actual target size, as opposed to the size of the delta data
+            streams = self.collect_streams_at_offset(offset)
+            buf = streams[0].read(512)
+            offset, src_size = msb_size(buf)
+            offset, target_size = msb_size(buf, offset)
+
+            # collect the streams to obtain the actual object type
+            if streams[-1].type_id in delta_types:
+                raise BadObject(sha, "Could not resolve delta object")
+            return OInfo(sha, streams[-1].type, target_size)
+        # END handle stream
+
+    #{ Read-Database like Interface
+
+    def info(self, sha):
+        """Retrieve information about the object identified by the given sha
+
+        :param sha: 20 byte sha1
+        :raise BadObject:
+        :return: OInfo instance, with 20 byte sha"""
+        return self._object(sha, False)
+
+    def stream(self, sha):
+        """Retrieve an object stream along with its information as identified by the given sha
+
+        :param sha: 20 byte sha1
+        :raise BadObject:
+        :return: OStream instance, with 20 byte sha"""
+        return self._object(sha, True)
+
+    def info_at_index(self, index):
+        """As ``info``, but uses a PackIndexFile compatible index to refer to the object"""
+        return self._object(None, False, index)
+
+    def stream_at_index(self, index):
+        """As ``stream``, but uses a PackIndexFile compatible index to refer to the
+        object"""
+        return self._object(None, True, index)
+
+    #} END Read-Database like Interface
+
+    #{ Interface
+
+    def pack(self):
+        """:return: the underlying pack file instance"""
+        return self._pack
+
+    def index(self):
+        """:return: the underlying pack index file instance"""
+        return self._index
+
+    def is_valid_stream(self, sha, use_crc=False):
+        """
+        Verify that the stream at the given sha is valid.
+
+        :param use_crc: if True, the index' crc is run over the compressed stream of
+            the object, which is much faster than checking the sha1. It is also
+            more prone to unnoticed corruption or manipulation.
+        :param sha: 20 byte sha1 of the object whose stream to verify
+            whether the compressed stream of the object is valid. If it is
+            a delta, this only verifies that the delta's data is valid, not the
+            data of the actual undeltified object, as it depends on more than
+            just this stream.
+            If False, the object will be decompressed and the sha generated. It must
+            match the given sha
+
+        :return: True if the stream is valid
+        :raise UnsupportedOperation: If the index is version 1 only
+        :raise BadObject: sha was not found"""
+        if use_crc:
+            if self._index.version() < 2:
+                raise UnsupportedOperation("Version 1 indices do not contain crc's, verify by sha instead")
+            # END handle index version
+
+            index = self._sha_to_index(sha)
+            offset = self._index.offset(index)
+            next_offset = self._offset_map[offset]
+            crc_value = self._index.crc(index)
+
+            # create the current crc value, on the compressed object data
+            # Read it in chunks, without copying the data
+            crc_update = zlib.crc32
+            pack_data = self._pack.data()
+            cur_pos = offset
+            this_crc_value = 0
+            while cur_pos < next_offset:
+                rbound = min(cur_pos + chunk_size, next_offset)
+                size = rbound - cur_pos
+                this_crc_value = crc_update(pack_data[cur_pos:cur_pos + size], this_crc_value)
+                cur_pos += size
+            # END window size loop
+
+            # crc returns signed 32 bit numbers, the AND op forces it into unsigned
+            # mode ... wow, sneaky, from dulwich.
+            return (this_crc_value & 0xffffffff) == crc_value
+        else:
+            shawriter = Sha1Writer()
+            stream = self._object(sha, as_stream=True)
+            # write a loose object, which is the basis for the sha
+            write_object(stream.type, stream.size, stream.read, shawriter.write)
+
+            assert shawriter.sha(as_hex=False) == sha
+            return shawriter.sha(as_hex=False) == sha
+        # END handle crc/sha verification
+        return True
+
+    def info_iter(self):
+        """
+        :return: Iterator over all objects in this pack. The iterator yields
+            OInfo instances"""
+        return self._iter_objects(as_stream=False)
+
+    def stream_iter(self):
+        """
+        :return: iterator over all objects in this pack. The iterator yields
+            OStream instances"""
+        return self._iter_objects(as_stream=True)
+
+    def collect_streams_at_offset(self, offset):
+        """
+        As the version in the PackFile, but can resolve REF deltas within this pack
+        For more info, see ``collect_streams``
+
+        :param offset: offset into the pack file at which the object can be found"""
+        streams = self._pack.collect_streams(offset)
+
+        # try to resolve the last one if needed. It is assumed to be either
+        # a REF delta, or a base object, as OFFSET deltas are resolved by the pack
+        if streams[-1].type_id == REF_DELTA:
+            stream = streams[-1]
+            while stream.type_id in delta_types:
+                if stream.type_id == REF_DELTA:
+                    # smmap can return memory view objects, which can't be compared as buffers/bytes can ...
+                    if isinstance(stream.delta_info, memoryview):
+                        sindex = self._index.sha_to_index(stream.delta_info.tobytes())
+                    else:
+                        sindex = self._index.sha_to_index(stream.delta_info)
+                    if sindex is None:
+                        break
+                    stream = self._pack.stream(self._index.offset(sindex))
+                    streams.append(stream)
+                else:
+                    # must be another OFS DELTA - this could happen if a REF
+                    # delta we resolve previously points to an OFS delta. Who
+                    # would do that ;) ? We can handle it though
+                    stream = self._pack.stream(stream.delta_info)
+                    streams.append(stream)
+                # END handle ref delta
+            # END resolve ref streams
+        # END resolve streams
+
+        return streams
+
+    def collect_streams(self, sha):
+        """
+        As ``PackFile.collect_streams``, but takes a sha instead of an offset.
+        Additionally, ref_delta streams will be resolved within this pack.
+        If this is not possible, the stream will be left alone, hence it is adivsed
+        to check for unresolved ref-deltas and resolve them before attempting to
+        construct a delta stream.
+
+        :param sha: 20 byte sha1 specifying the object whose related streams you want to collect
+        :return: list of streams, first being the actual object delta, the last being
+            a possibly unresolved base object.
+        :raise BadObject:"""
+        return self.collect_streams_at_offset(self._index.offset(self._sha_to_index(sha)))
+
+    @classmethod
+    def write_pack(cls, object_iter, pack_write, index_write=None,
+                   object_count=None, zlib_compression=zlib.Z_BEST_SPEED):
+        """
+        Create a new pack by putting all objects obtained by the object_iterator
+        into a pack which is written using the pack_write method.
+        The respective index is produced as well if index_write is not Non.
+
+        :param object_iter: iterator yielding odb output objects
+        :param pack_write: function to receive strings to write into the pack stream
+        :param indx_write: if not None, the function writes the index file corresponding
+            to the pack.
+        :param object_count: if you can provide the amount of objects in your iteration,
+            this would be the place to put it. Otherwise we have to pre-iterate and store
+            all items into a list to get the number, which uses more memory than necessary.
+        :param zlib_compression: the zlib compression level to use
+        :return: tuple(pack_sha, index_binsha) binary sha over all the contents of the pack
+            and over all contents of the index. If index_write was None, index_binsha will be None
+
+        **Note:** The destination of the write functions is up to the user. It could
+        be a socket, or a file for instance
+
+        **Note:** writes only undeltified objects"""
+        objs = object_iter
+        if not object_count:
+            if not isinstance(object_iter, (tuple, list)):
+                objs = list(object_iter)
+            # END handle list type
+            object_count = len(objs)
+        # END handle object
+
+        pack_writer = FlexibleSha1Writer(pack_write)
+        pwrite = pack_writer.write
+        ofs = 0                                         # current offset into the pack file
+        index = None
+        wants_index = index_write is not None
+
+        # write header
+        pwrite(pack('>LLL', PackFile.pack_signature, PackFile.pack_version_default, object_count))
+        ofs += 12
+
+        if wants_index:
+            index = IndexWriter()
+        # END handle index header
+
+        actual_count = 0
+        for obj in objs:
+            actual_count += 1
+            crc = 0
+
+            # object header
+            hdr = create_pack_object_header(obj.type_id, obj.size)
+            if index_write:
+                crc = crc32(hdr)
+            else:
+                crc = None
+            # END handle crc
+            pwrite(hdr)
+
+            # data stream
+            zstream = zlib.compressobj(zlib_compression)
+            ostream = obj.stream
+            br, bw, crc = write_stream_to_pack(ostream.read, pwrite, zstream, base_crc=crc)
+            assert(br == obj.size)
+            if wants_index:
+                index.append(obj.binsha, crc, ofs)
+            # END handle index
+
+            ofs += len(hdr) + bw
+            if actual_count == object_count:
+                break
+            # END abort once we are done
+        # END for each object
+
+        if actual_count != object_count:
+            raise ValueError(
+                "Expected to write %i objects into pack, but received only %i from iterators" % (object_count, actual_count))
+        # END count assertion
+
+        # write footer
+        pack_sha = pack_writer.sha(as_hex=False)
+        assert len(pack_sha) == 20
+        pack_write(pack_sha)
+        ofs += len(pack_sha)                            # just for completeness ;)
+
+        index_sha = None
+        if wants_index:
+            index_sha = index.write(pack_sha, index_write)
+        # END handle index
+
+        return pack_sha, index_sha
+
+    @classmethod
+    def create(cls, object_iter, base_dir, object_count=None, zlib_compression=zlib.Z_BEST_SPEED):
+        """Create a new on-disk entity comprised of a properly named pack file and a properly named
+        and corresponding index file. The pack contains all OStream objects contained in object iter.
+        :param base_dir: directory which is to contain the files
+        :return: PackEntity instance initialized with the new pack
+
+        **Note:** for more information on the other parameters see the write_pack method"""
+        pack_fd, pack_path = tempfile.mkstemp('', 'pack', base_dir)
+        index_fd, index_path = tempfile.mkstemp('', 'index', base_dir)
+        pack_write = lambda d: os.write(pack_fd, d)
+        index_write = lambda d: os.write(index_fd, d)
+
+        pack_binsha, index_binsha = cls.write_pack(object_iter, pack_write, index_write, object_count, zlib_compression)
+        os.close(pack_fd)
+        os.close(index_fd)
+
+        fmt = "pack-%s.%s"
+        new_pack_path = os.path.join(base_dir, fmt % (bin_to_hex(pack_binsha), 'pack'))
+        new_index_path = os.path.join(base_dir, fmt % (bin_to_hex(pack_binsha), 'idx'))
+        os.rename(pack_path, new_pack_path)
+        os.rename(index_path, new_index_path)
+
+        return cls(new_pack_path)
+
+    #} END interface

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/stream.py

@@ -0,0 +1,730 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+from io import BytesIO
+
+import mmap
+import os
+import sys
+import zlib
+
+from gitdb.fun import (
+    msb_size,
+    stream_copy,
+    apply_delta_data,
+    connect_deltas,
+    delta_types
+)
+
+from gitdb.util import (
+    allocate_memory,
+    LazyMixin,
+    make_sha,
+    write,
+    close,
+)
+
+from gitdb.const import NULL_BYTE, BYTE_SPACE
+from gitdb.utils.encoding import force_bytes
+
+has_perf_mod = False
+try:
+    from gitdb_speedups._perf import apply_delta as c_apply_delta
+    has_perf_mod = True
+except ImportError:
+    pass
+
+__all__ = ('DecompressMemMapReader', 'FDCompressedSha1Writer', 'DeltaApplyReader',
+           'Sha1Writer', 'FlexibleSha1Writer', 'ZippedStoreShaWriter', 'FDCompressedSha1Writer',
+           'FDStream', 'NullStream')
+
+
+#{ RO Streams
+
+class DecompressMemMapReader(LazyMixin):
+
+    """Reads data in chunks from a memory map and decompresses it. The client sees
+    only the uncompressed data, respective file-like read calls are handling on-demand
+    buffered decompression accordingly
+
+    A constraint on the total size of bytes is activated, simulating
+    a logical file within a possibly larger physical memory area
+
+    To read efficiently, you clearly don't want to read individual bytes, instead,
+    read a few kilobytes at least.
+
+    **Note:** The chunk-size should be carefully selected as it will involve quite a bit
+        of string copying due to the way the zlib is implemented. Its very wasteful,
+        hence we try to find a good tradeoff between allocation time and number of
+        times we actually allocate. An own zlib implementation would be good here
+        to better support streamed reading - it would only need to keep the mmap
+        and decompress it into chunks, that's all ... """
+    __slots__ = ('_m', '_zip', '_buf', '_buflen', '_br', '_cws', '_cwe', '_s', '_close',
+                 '_cbr', '_phi')
+
+    max_read_size = 512 * 1024        # currently unused
+
+    def __init__(self, m, close_on_deletion, size=None):
+        """Initialize with mmap for stream reading
+        :param m: must be content data - use new if you have object data and no size"""
+        self._m = m
+        self._zip = zlib.decompressobj()
+        self._buf = None                        # buffer of decompressed bytes
+        self._buflen = 0                        # length of bytes in buffer
+        if size is not None:
+            self._s = size                      # size of uncompressed data to read in total
+        self._br = 0                            # num uncompressed bytes read
+        self._cws = 0                           # start byte of compression window
+        self._cwe = 0                           # end byte of compression window
+        self._cbr = 0                           # number of compressed bytes read
+        self._phi = False                       # is True if we parsed the header info
+        self._close = close_on_deletion         # close the memmap on deletion ?
+
+    def _set_cache_(self, attr):
+        assert attr == '_s'
+        # only happens for size, which is a marker to indicate we still
+        # have to parse the header from the stream
+        self._parse_header_info()
+
+    def __del__(self):
+        self.close()
+
+    def _parse_header_info(self):
+        """If this stream contains object data, parse the header info and skip the
+        stream to a point where each read will yield object content
+
+        :return: parsed type_string, size"""
+        # read header
+        # should really be enough, cgit uses 8192 I believe
+        # And for good reason !! This needs to be that high for the header to be read correctly in all cases
+        maxb = 8192
+        self._s = maxb
+        hdr = self.read(maxb)
+        hdrend = hdr.find(NULL_BYTE)
+        typ, size = hdr[:hdrend].split(BYTE_SPACE)
+        size = int(size)
+        self._s = size
+
+        # adjust internal state to match actual header length that we ignore
+        # The buffer will be depleted first on future reads
+        self._br = 0
+        hdrend += 1
+        self._buf = BytesIO(hdr[hdrend:])
+        self._buflen = len(hdr) - hdrend
+
+        self._phi = True
+
+        return typ, size
+
+    #{ Interface
+
+    @classmethod
+    def new(self, m, close_on_deletion=False):
+        """Create a new DecompressMemMapReader instance for acting as a read-only stream
+        This method parses the object header from m and returns the parsed
+        type and size, as well as the created stream instance.
+
+        :param m: memory map on which to operate. It must be object data ( header + contents )
+        :param close_on_deletion: if True, the memory map will be closed once we are
+            being deleted"""
+        inst = DecompressMemMapReader(m, close_on_deletion, 0)
+        typ, size = inst._parse_header_info()
+        return typ, size, inst
+
+    def data(self):
+        """:return: random access compatible data we are working on"""
+        return self._m
+
+    def close(self):
+        """Close our underlying stream of compressed bytes if this was allowed during initialization
+        :return: True if we closed the underlying stream
+        :note: can be called safely 
+        """
+        if self._close:
+            if hasattr(self._m, 'close'):
+                self._m.close()
+            self._close = False
+        # END handle resource freeing
+
+    def compressed_bytes_read(self):
+        """
+        :return: number of compressed bytes read. This includes the bytes it
+            took to decompress the header ( if there was one )"""
+        # ABSTRACT: When decompressing a byte stream, it can be that the first
+        # x bytes which were requested match the first x bytes in the loosely
+        # compressed datastream. This is the worst-case assumption that the reader
+        # does, it assumes that it will get at least X bytes from X compressed bytes
+        # in call cases.
+        # The caveat is that the object, according to our known uncompressed size,
+        # is already complete, but there are still some bytes left in the compressed
+        # stream that contribute to the amount of compressed bytes.
+        # How can we know that we are truly done, and have read all bytes we need
+        # to read ?
+        # Without help, we cannot know, as we need to obtain the status of the
+        # decompression. If it is not finished, we need to decompress more data
+        # until it is finished, to yield the actual number of compressed bytes
+        # belonging to the decompressed object
+        # We are using a custom zlib module for this, if its not present,
+        # we try to put in additional bytes up for decompression if feasible
+        # and check for the unused_data.
+
+        # Only scrub the stream forward if we are officially done with the
+        # bytes we were to have.
+        if self._br == self._s and not self._zip.unused_data:
+            # manipulate the bytes-read to allow our own read method to continue
+            # but keep the window at its current position
+            self._br = 0
+            if hasattr(self._zip, 'status'):
+                while self._zip.status == zlib.Z_OK:
+                    self.read(mmap.PAGESIZE)
+                # END scrub-loop custom zlib
+            else:
+                # pass in additional pages, until we have unused data
+                while not self._zip.unused_data and self._cbr != len(self._m):
+                    self.read(mmap.PAGESIZE)
+                # END scrub-loop default zlib
+            # END handle stream scrubbing
+
+            # reset bytes read, just to be sure
+            self._br = self._s
+        # END handle stream scrubbing
+
+        # unused data ends up in the unconsumed tail, which was removed
+        # from the count already
+        return self._cbr
+
+    #} END interface
+
+    def seek(self, offset, whence=getattr(os, 'SEEK_SET', 0)):
+        """Allows to reset the stream to restart reading
+        :raise ValueError: If offset and whence are not 0"""
+        if offset != 0 or whence != getattr(os, 'SEEK_SET', 0):
+            raise ValueError("Can only seek to position 0")
+        # END handle offset
+
+        self._zip = zlib.decompressobj()
+        self._br = self._cws = self._cwe = self._cbr = 0
+        if self._phi:
+            self._phi = False
+            del(self._s)        # trigger header parsing on first access
+        # END skip header
+
+    def read(self, size=-1):
+        if size < 1:
+            size = self._s - self._br
+        else:
+            size = min(size, self._s - self._br)
+        # END clamp size
+
+        if size == 0:
+            return bytes()
+        # END handle depletion
+
+        # deplete the buffer, then just continue using the decompress object
+        # which has an own buffer. We just need this to transparently parse the
+        # header from the zlib stream
+        dat = bytes()
+        if self._buf:
+            if self._buflen >= size:
+                # have enough data
+                dat = self._buf.read(size)
+                self._buflen -= size
+                self._br += size
+                return dat
+            else:
+                dat = self._buf.read()      # ouch, duplicates data
+                size -= self._buflen
+                self._br += self._buflen
+
+                self._buflen = 0
+                self._buf = None
+            # END handle buffer len
+        # END handle buffer
+
+        # decompress some data
+        # Abstract: zlib needs to operate on chunks of our memory map ( which may
+        # be large ), as it will otherwise and always fill in the 'unconsumed_tail'
+        # attribute which possible reads our whole map to the end, forcing
+        # everything to be read from disk even though just a portion was requested.
+        # As this would be a nogo, we workaround it by passing only chunks of data,
+        # moving the window into the memory map along as we decompress, which keeps
+        # the tail smaller than our chunk-size. This causes 'only' the chunk to be
+        # copied once, and another copy of a part of it when it creates the unconsumed
+        # tail. We have to use it to hand in the appropriate amount of bytes during
+        # the next read.
+        tail = self._zip.unconsumed_tail
+        if tail:
+            # move the window, make it as large as size demands. For code-clarity,
+            # we just take the chunk from our map again instead of reusing the unconsumed
+            # tail. The latter one would safe some memory copying, but we could end up
+            # with not getting enough data uncompressed, so we had to sort that out as well.
+            # Now we just assume the worst case, hence the data is uncompressed and the window
+            # needs to be as large as the uncompressed bytes we want to read.
+            self._cws = self._cwe - len(tail)
+            self._cwe = self._cws + size
+        else:
+            cws = self._cws
+            self._cws = self._cwe
+            self._cwe = cws + size
+        # END handle tail
+
+        # if window is too small, make it larger so zip can decompress something
+        if self._cwe - self._cws < 8:
+            self._cwe = self._cws + 8
+        # END adjust winsize
+
+        # takes a slice, but doesn't copy the data, it says ...
+        indata = self._m[self._cws:self._cwe]
+
+        # get the actual window end to be sure we don't use it for computations
+        self._cwe = self._cws + len(indata)
+        dcompdat = self._zip.decompress(indata, size)
+        # update the amount of compressed bytes read
+        # We feed possibly overlapping chunks, which is why the unconsumed tail
+        # has to be taken into consideration, as well as the unused data
+        # if we hit the end of the stream
+        # NOTE: Behavior changed in PY2.7 onward, which requires special handling to make the tests work properly.
+        # They are thorough, and I assume it is truly working.
+        # Why is this logic as convoluted as it is ? Please look at the table in 
+        # https://github.com/gitpython-developers/gitdb/issues/19 to learn about the test-results.
+        # Bascially, on py2.6, you want to use branch 1, whereas on all other python version, the second branch
+        # will be the one that works. 
+        # However, the zlib VERSIONs as well as the platform check is used to further match the entries in the 
+        # table in the github issue. This is it ... it was the only way I could make this work everywhere.
+        # IT's CERTAINLY GOING TO BITE US IN THE FUTURE ... .
+        if zlib.ZLIB_VERSION in ('1.2.7', '1.2.5') and not sys.platform == 'darwin':
+            unused_datalen = len(self._zip.unconsumed_tail)
+        else:
+            unused_datalen = len(self._zip.unconsumed_tail) + len(self._zip.unused_data)
+        # # end handle very special case ...
+
+        self._cbr += len(indata) - unused_datalen
+        self._br += len(dcompdat)
+
+        if dat:
+            dcompdat = dat + dcompdat
+        # END prepend our cached data
+
+        # it can happen, depending on the compression, that we get less bytes
+        # than ordered as it needs the final portion of the data as well.
+        # Recursively resolve that.
+        # Note: dcompdat can be empty even though we still appear to have bytes
+        # to read, if we are called by compressed_bytes_read - it manipulates
+        # us to empty the stream
+        if dcompdat and (len(dcompdat) - len(dat)) < size and self._br < self._s:
+            dcompdat += self.read(size - len(dcompdat))
+        # END handle special case
+        return dcompdat
+
+
+class DeltaApplyReader(LazyMixin):
+
+    """A reader which dynamically applies pack deltas to a base object, keeping the
+    memory demands to a minimum.
+
+    The size of the final object is only obtainable once all deltas have been
+    applied, unless it is retrieved from a pack index.
+
+    The uncompressed Delta has the following layout (MSB being a most significant
+    bit encoded dynamic size):
+
+    * MSB Source Size - the size of the base against which the delta was created
+    * MSB Target Size - the size of the resulting data after the delta was applied
+    * A list of one byte commands (cmd) which are followed by a specific protocol:
+
+     * cmd & 0x80 - copy delta_data[offset:offset+size]
+
+      * Followed by an encoded offset into the delta data
+      * Followed by an encoded size of the chunk to copy
+
+     *  cmd & 0x7f - insert
+
+      * insert cmd bytes from the delta buffer into the output stream
+
+     * cmd == 0 - invalid operation ( or error in delta stream )
+    """
+    __slots__ = (
+        "_bstream",             # base stream to which to apply the deltas
+        "_dstreams",            # tuple of delta stream readers
+        "_mm_target",           # memory map of the delta-applied data
+        "_size",                # actual number of bytes in _mm_target
+        "_br"                   # number of bytes read
+    )
+
+    #{ Configuration
+    k_max_memory_move = 250 * 1000 * 1000
+    #} END configuration
+
+    def __init__(self, stream_list):
+        """Initialize this instance with a list of streams, the first stream being
+        the delta to apply on top of all following deltas, the last stream being the
+        base object onto which to apply the deltas"""
+        assert len(stream_list) > 1, "Need at least one delta and one base stream"
+
+        self._bstream = stream_list[-1]
+        self._dstreams = tuple(stream_list[:-1])
+        self._br = 0
+
+    def _set_cache_too_slow_without_c(self, attr):
+        # the direct algorithm is fastest and most direct if there is only one
+        # delta. Also, the extra overhead might not be worth it for items smaller
+        # than X - definitely the case in python, every function call costs
+        # huge amounts of time
+        # if len(self._dstreams) * self._bstream.size < self.k_max_memory_move:
+        if len(self._dstreams) == 1:
+            return self._set_cache_brute_(attr)
+
+        # Aggregate all deltas into one delta in reverse order. Hence we take
+        # the last delta, and reverse-merge its ancestor delta, until we receive
+        # the final delta data stream.
+        dcl = connect_deltas(self._dstreams)
+
+        # call len directly, as the (optional) c version doesn't implement the sequence
+        # protocol
+        if dcl.rbound() == 0:
+            self._size = 0
+            self._mm_target = allocate_memory(0)
+            return
+        # END handle empty list
+
+        self._size = dcl.rbound()
+        self._mm_target = allocate_memory(self._size)
+
+        bbuf = allocate_memory(self._bstream.size)
+        stream_copy(self._bstream.read, bbuf.write, self._bstream.size, 256 * mmap.PAGESIZE)
+
+        # APPLY CHUNKS
+        write = self._mm_target.write
+        dcl.apply(bbuf, write)
+
+        self._mm_target.seek(0)
+
+    def _set_cache_brute_(self, attr):
+        """If we are here, we apply the actual deltas"""
+        # TODO: There should be a special case if there is only one stream
+        # Then the default-git algorithm should perform a tad faster, as the
+        # delta is not peaked into, causing less overhead.
+        buffer_info_list = list()
+        max_target_size = 0
+        for dstream in self._dstreams:
+            buf = dstream.read(512)         # read the header information + X
+            offset, src_size = msb_size(buf)
+            offset, target_size = msb_size(buf, offset)
+            buffer_info_list.append((buf[offset:], offset, src_size, target_size))
+            max_target_size = max(max_target_size, target_size)
+        # END for each delta stream
+
+        # sanity check - the first delta to apply should have the same source
+        # size as our actual base stream
+        base_size = self._bstream.size
+        target_size = max_target_size
+
+        # if we have more than 1 delta to apply, we will swap buffers, hence we must
+        # assure that all buffers we use are large enough to hold all the results
+        if len(self._dstreams) > 1:
+            base_size = target_size = max(base_size, max_target_size)
+        # END adjust buffer sizes
+
+        # Allocate private memory map big enough to hold the first base buffer
+        # We need random access to it
+        bbuf = allocate_memory(base_size)
+        stream_copy(self._bstream.read, bbuf.write, base_size, 256 * mmap.PAGESIZE)
+
+        # allocate memory map large enough for the largest (intermediate) target
+        # We will use it as scratch space for all delta ops. If the final
+        # target buffer is smaller than our allocated space, we just use parts
+        # of it upon return.
+        tbuf = allocate_memory(target_size)
+
+        # for each delta to apply, memory map the decompressed delta and
+        # work on the op-codes to reconstruct everything.
+        # For the actual copying, we use a seek and write pattern of buffer
+        # slices.
+        final_target_size = None
+        for (dbuf, offset, src_size, target_size), dstream in zip(reversed(buffer_info_list), reversed(self._dstreams)):
+            # allocate a buffer to hold all delta data - fill in the data for
+            # fast access. We do this as we know that reading individual bytes
+            # from our stream would be slower than necessary ( although possible )
+            # The dbuf buffer contains commands after the first two MSB sizes, the
+            # offset specifies the amount of bytes read to get the sizes.
+            ddata = allocate_memory(dstream.size - offset)
+            ddata.write(dbuf)
+            # read the rest from the stream. The size we give is larger than necessary
+            stream_copy(dstream.read, ddata.write, dstream.size, 256 * mmap.PAGESIZE)
+
+            #######################################################################
+            if 'c_apply_delta' in globals():
+                c_apply_delta(bbuf, ddata, tbuf)
+            else:
+                apply_delta_data(bbuf, src_size, ddata, len(ddata), tbuf.write)
+            #######################################################################
+
+            # finally, swap out source and target buffers. The target is now the
+            # base for the next delta to apply
+            bbuf, tbuf = tbuf, bbuf
+            bbuf.seek(0)
+            tbuf.seek(0)
+            final_target_size = target_size
+        # END for each delta to apply
+
+        # its already seeked to 0, constrain it to the actual size
+        # NOTE: in the end of the loop, it swaps buffers, hence our target buffer
+        # is not tbuf, but bbuf !
+        self._mm_target = bbuf
+        self._size = final_target_size
+
+    #{ Configuration
+    if not has_perf_mod:
+        _set_cache_ = _set_cache_brute_
+    else:
+        _set_cache_ = _set_cache_too_slow_without_c
+
+    #} END configuration
+
+    def read(self, count=0):
+        bl = self._size - self._br      # bytes left
+        if count < 1 or count > bl:
+            count = bl
+        # NOTE: we could check for certain size limits, and possibly
+        # return buffers instead of strings to prevent byte copying
+        data = self._mm_target.read(count)
+        self._br += len(data)
+        return data
+
+    def seek(self, offset, whence=getattr(os, 'SEEK_SET', 0)):
+        """Allows to reset the stream to restart reading
+
+        :raise ValueError: If offset and whence are not 0"""
+        if offset != 0 or whence != getattr(os, 'SEEK_SET', 0):
+            raise ValueError("Can only seek to position 0")
+        # END handle offset
+        self._br = 0
+        self._mm_target.seek(0)
+
+    #{ Interface
+
+    @classmethod
+    def new(cls, stream_list):
+        """
+        Convert the given list of streams into a stream which resolves deltas
+        when reading from it.
+
+        :param stream_list: two or more stream objects, first stream is a Delta
+            to the object that you want to resolve, followed by N additional delta
+            streams. The list's last stream must be a non-delta stream.
+
+        :return: Non-Delta OPackStream object whose stream can be used to obtain
+            the decompressed resolved data
+        :raise ValueError: if the stream list cannot be handled"""
+        if len(stream_list) < 2:
+            raise ValueError("Need at least two streams")
+        # END single object special handling
+
+        if stream_list[-1].type_id in delta_types:
+            raise ValueError(
+                "Cannot resolve deltas if there is no base object stream, last one was type: %s" % stream_list[-1].type)
+        # END check stream
+        return cls(stream_list)
+
+    #} END interface
+
+    #{ OInfo like Interface
+
+    @property
+    def type(self):
+        return self._bstream.type
+
+    @property
+    def type_id(self):
+        return self._bstream.type_id
+
+    @property
+    def size(self):
+        """:return: number of uncompressed bytes in the stream"""
+        return self._size
+
+    #} END oinfo like interface
+
+
+#} END RO streams
+
+
+#{ W Streams
+
+class Sha1Writer(object):
+
+    """Simple stream writer which produces a sha whenever you like as it degests
+    everything it is supposed to write"""
+    __slots__ = "sha1"
+
+    def __init__(self):
+        self.sha1 = make_sha()
+
+    #{ Stream Interface
+
+    def write(self, data):
+        """:raise IOError: If not all bytes could be written
+        :param data: byte object
+        :return: length of incoming data"""
+
+        self.sha1.update(data)
+
+        return len(data)
+
+    # END stream interface
+
+    #{ Interface
+
+    def sha(self, as_hex=False):
+        """:return: sha so far
+        :param as_hex: if True, sha will be hex-encoded, binary otherwise"""
+        if as_hex:
+            return self.sha1.hexdigest()
+        return self.sha1.digest()
+
+    #} END interface
+
+
+class FlexibleSha1Writer(Sha1Writer):
+
+    """Writer producing a sha1 while passing on the written bytes to the given
+    write function"""
+    __slots__ = 'writer'
+
+    def __init__(self, writer):
+        Sha1Writer.__init__(self)
+        self.writer = writer
+
+    def write(self, data):
+        Sha1Writer.write(self, data)
+        self.writer(data)
+
+
+class ZippedStoreShaWriter(Sha1Writer):
+
+    """Remembers everything someone writes to it and generates a sha"""
+    __slots__ = ('buf', 'zip')
+
+    def __init__(self):
+        Sha1Writer.__init__(self)
+        self.buf = BytesIO()
+        self.zip = zlib.compressobj(zlib.Z_BEST_SPEED)
+
+    def __getattr__(self, attr):
+        return getattr(self.buf, attr)
+
+    def write(self, data):
+        alen = Sha1Writer.write(self, data)
+        self.buf.write(self.zip.compress(data))
+
+        return alen
+
+    def close(self):
+        self.buf.write(self.zip.flush())
+
+    def seek(self, offset, whence=getattr(os, 'SEEK_SET', 0)):
+        """Seeking currently only supports to rewind written data
+        Multiple writes are not supported"""
+        if offset != 0 or whence != getattr(os, 'SEEK_SET', 0):
+            raise ValueError("Can only seek to position 0")
+        # END handle offset
+        self.buf.seek(0)
+
+    def getvalue(self):
+        """:return: string value from the current stream position to the end"""
+        return self.buf.getvalue()
+
+
+class FDCompressedSha1Writer(Sha1Writer):
+
+    """Digests data written to it, making the sha available, then compress the
+    data and write it to the file descriptor
+
+    **Note:** operates on raw file descriptors
+    **Note:** for this to work, you have to use the close-method of this instance"""
+    __slots__ = ("fd", "sha1", "zip")
+
+    # default exception
+    exc = IOError("Failed to write all bytes to filedescriptor")
+
+    def __init__(self, fd):
+        super(FDCompressedSha1Writer, self).__init__()
+        self.fd = fd
+        self.zip = zlib.compressobj(zlib.Z_BEST_SPEED)
+
+    #{ Stream Interface
+
+    def write(self, data):
+        """:raise IOError: If not all bytes could be written
+        :return: length of incoming data"""
+        self.sha1.update(data)
+        cdata = self.zip.compress(data)
+        bytes_written = write(self.fd, cdata)
+
+        if bytes_written != len(cdata):
+            raise self.exc
+
+        return len(data)
+
+    def close(self):
+        remainder = self.zip.flush()
+        if write(self.fd, remainder) != len(remainder):
+            raise self.exc
+        return close(self.fd)
+
+    #} END stream interface
+
+
+class FDStream(object):
+
+    """A simple wrapper providing the most basic functions on a file descriptor
+    with the fileobject interface. Cannot use os.fdopen as the resulting stream
+    takes ownership"""
+    __slots__ = ("_fd", '_pos')
+
+    def __init__(self, fd):
+        self._fd = fd
+        self._pos = 0
+
+    def write(self, data):
+        self._pos += len(data)
+        os.write(self._fd, data)
+
+    def read(self, count=0):
+        if count == 0:
+            count = os.path.getsize(self._filepath)
+        # END handle read everything
+
+        bytes = os.read(self._fd, count)
+        self._pos += len(bytes)
+        return bytes
+
+    def fileno(self):
+        return self._fd
+
+    def tell(self):
+        return self._pos
+
+    def close(self):
+        close(self._fd)
+
+
+class NullStream(object):
+
+    """A stream that does nothing but providing a stream interface.
+    Use it like /dev/null"""
+    __slots__ = tuple()
+
+    def read(self, size=0):
+        return ''
+
+    def close(self):
+        pass
+
+    def write(self, data):
+        return len(data)
+
+
+#} END W streams

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/typ.py

@@ -0,0 +1,10 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+"""Module containing information about types known to the database"""
+
+str_blob_type = b'blob'
+str_commit_type = b'commit'
+str_tree_type = b'tree'
+str_tag_type = b'tag'

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/gitdb/util.py

@@ -0,0 +1,398 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
+import binascii
+import os
+import mmap
+import sys
+import time
+import errno
+
+from io import BytesIO
+
+from smmap import (
+    StaticWindowMapManager,
+    SlidingWindowMapManager,
+    SlidingWindowMapBuffer
+)
+
+# initialize our global memory manager instance
+# Use it to free cached (and unused) resources.
+mman = SlidingWindowMapManager()
+# END handle mman
+
+import hashlib
+
+try:
+    from struct import unpack_from
+except ImportError:
+    from struct import unpack, calcsize
+    __calcsize_cache = dict()
+
+    def unpack_from(fmt, data, offset=0):
+        try:
+            size = __calcsize_cache[fmt]
+        except KeyError:
+            size = calcsize(fmt)
+            __calcsize_cache[fmt] = size
+        # END exception handling
+        return unpack(fmt, data[offset: offset + size])
+    # END own unpack_from implementation
+
+
+#{ Aliases
+
+hex_to_bin = binascii.a2b_hex
+bin_to_hex = binascii.b2a_hex
+
+# errors
+ENOENT = errno.ENOENT
+
+# os shortcuts
+exists = os.path.exists
+mkdir = os.mkdir
+chmod = os.chmod
+isdir = os.path.isdir
+isfile = os.path.isfile
+rename = os.rename
+dirname = os.path.dirname
+basename = os.path.basename
+join = os.path.join
+read = os.read
+write = os.write
+close = os.close
+fsync = os.fsync
+
+
+def _retry(func, *args, **kwargs):
+    # Wrapper around functions, that are problematic on "Windows". Sometimes
+    # the OS or someone else has still a handle to the file
+    if sys.platform == "win32":
+        for _ in range(10):
+            try:
+                return func(*args, **kwargs)
+            except Exception:
+                time.sleep(0.1)
+        return func(*args, **kwargs)
+    else:
+        return func(*args, **kwargs)
+
+
+def remove(*args, **kwargs):
+    return _retry(os.remove, *args, **kwargs)
+
+
+# Backwards compatibility imports
+from gitdb.const import (
+    NULL_BIN_SHA,
+    NULL_HEX_SHA
+)
+
+#} END Aliases
+
+#{ compatibility stuff ...
+
+
+class _RandomAccessBytesIO(object):
+
+    """Wrapper to provide required functionality in case memory maps cannot or may
+    not be used. This is only really required in python 2.4"""
+    __slots__ = '_sio'
+
+    def __init__(self, buf=''):
+        self._sio = BytesIO(buf)
+
+    def __getattr__(self, attr):
+        return getattr(self._sio, attr)
+
+    def __len__(self):
+        return len(self.getvalue())
+
+    def __getitem__(self, i):
+        return self.getvalue()[i]
+
+    def __getslice__(self, start, end):
+        return self.getvalue()[start:end]
+
+
+def byte_ord(b):
+    """
+    Return the integer representation of the byte string.  This supports Python
+    3 byte arrays as well as standard strings.
+    """
+    try:
+        return ord(b)
+    except TypeError:
+        return b
+
+#} END compatibility stuff ...
+
+#{ Routines
+
+
+def make_sha(source=''.encode("ascii")):
+    """A python2.4 workaround for the sha/hashlib module fiasco
+
+    **Note** From the dulwich project """
+    try:
+        return hashlib.sha1(source)
+    except NameError:
+        import sha
+        sha1 = sha.sha(source)
+        return sha1
+
+
+def allocate_memory(size):
+    """:return: a file-protocol accessible memory block of the given size"""
+    if size == 0:
+        return _RandomAccessBytesIO(b'')
+    # END handle empty chunks gracefully
+
+    try:
+        return mmap.mmap(-1, size)  # read-write by default
+    except EnvironmentError:
+        # setup real memory instead
+        # this of course may fail if the amount of memory is not available in
+        # one chunk - would only be the case in python 2.4, being more likely on
+        # 32 bit systems.
+        return _RandomAccessBytesIO(b"\0" * size)
+    # END handle memory allocation
+
+
+def file_contents_ro(fd, stream=False, allow_mmap=True):
+    """:return: read-only contents of the file represented by the file descriptor fd
+
+    :param fd: file descriptor opened for reading
+    :param stream: if False, random access is provided, otherwise the stream interface
+        is provided.
+    :param allow_mmap: if True, its allowed to map the contents into memory, which
+        allows large files to be handled and accessed efficiently. The file-descriptor
+        will change its position if this is False"""
+    try:
+        if allow_mmap:
+            # supports stream and random access
+            try:
+                return mmap.mmap(fd, 0, access=mmap.ACCESS_READ)
+            except EnvironmentError:
+                # python 2.4 issue, 0 wants to be the actual size
+                return mmap.mmap(fd, os.fstat(fd).st_size, access=mmap.ACCESS_READ)
+            # END handle python 2.4
+    except OSError:
+        pass
+    # END exception handling
+
+    # read manully
+    contents = os.read(fd, os.fstat(fd).st_size)
+    if stream:
+        return _RandomAccessBytesIO(contents)
+    return contents
+
+
+def file_contents_ro_filepath(filepath, stream=False, allow_mmap=True, flags=0):
+    """Get the file contents at filepath as fast as possible
+
+    :return: random access compatible memory of the given filepath
+    :param stream: see ``file_contents_ro``
+    :param allow_mmap: see ``file_contents_ro``
+    :param flags: additional flags to pass to os.open
+    :raise OSError: If the file could not be opened
+
+    **Note** for now we don't try to use O_NOATIME directly as the right value needs to be
+    shared per database in fact. It only makes a real difference for loose object
+    databases anyway, and they use it with the help of the ``flags`` parameter"""
+    fd = os.open(filepath, os.O_RDONLY | getattr(os, 'O_BINARY', 0) | flags)
+    try:
+        return file_contents_ro(fd, stream, allow_mmap)
+    finally:
+        close(fd)
+    # END assure file is closed
+
+
+def sliding_ro_buffer(filepath, flags=0):
+    """
+    :return: a buffer compatible object which uses our mapped memory manager internally
+        ready to read the whole given filepath"""
+    return SlidingWindowMapBuffer(mman.make_cursor(filepath), flags=flags)
+
+
+def to_hex_sha(sha):
+    """:return: hexified version  of sha"""
+    if len(sha) == 40:
+        return sha
+    return bin_to_hex(sha)
+
+
+def to_bin_sha(sha):
+    if len(sha) == 20:
+        return sha
+    return hex_to_bin(sha)
+
+
+#} END routines
+
+
+#{ Utilities
+
+class LazyMixin(object):
+
+    """
+    Base class providing an interface to lazily retrieve attribute values upon
+    first access. If slots are used, memory will only be reserved once the attribute
+    is actually accessed and retrieved the first time. All future accesses will
+    return the cached value as stored in the Instance's dict or slot.
+    """
+
+    __slots__ = tuple()
+
+    def __getattr__(self, attr):
+        """
+        Whenever an attribute is requested that we do not know, we allow it
+        to be created and set. Next time the same attribute is reqeusted, it is simply
+        returned from our dict/slots. """
+        self._set_cache_(attr)
+        # will raise in case the cache was not created
+        return object.__getattribute__(self, attr)
+
+    def _set_cache_(self, attr):
+        """
+        This method should be overridden in the derived class.
+        It should check whether the attribute named by attr can be created
+        and cached. Do nothing if you do not know the attribute or call your subclass
+
+        The derived class may create as many additional attributes as it deems
+        necessary in case a git command returns more information than represented
+        in the single attribute."""
+        pass
+
+
+class LockedFD(object):
+
+    """
+    This class facilitates a safe read and write operation to a file on disk.
+    If we write to 'file', we obtain a lock file at 'file.lock' and write to
+    that instead. If we succeed, the lock file will be renamed to overwrite
+    the original file.
+
+    When reading, we obtain a lock file, but to prevent other writers from
+    succeeding while we are reading the file.
+
+    This type handles error correctly in that it will assure a consistent state
+    on destruction.
+
+    **note** with this setup, parallel reading is not possible"""
+    __slots__ = ("_filepath", '_fd', '_write')
+
+    def __init__(self, filepath):
+        """Initialize an instance with the givne filepath"""
+        self._filepath = filepath
+        self._fd = None
+        self._write = None          # if True, we write a file
+
+    def __del__(self):
+        # will do nothing if the file descriptor is already closed
+        if self._fd is not None:
+            self.rollback()
+
+    def _lockfilepath(self):
+        return "%s.lock" % self._filepath
+
+    def open(self, write=False, stream=False):
+        """
+        Open the file descriptor for reading or writing, both in binary mode.
+
+        :param write: if True, the file descriptor will be opened for writing. Other
+            wise it will be opened read-only.
+        :param stream: if True, the file descriptor will be wrapped into a simple stream
+            object which supports only reading or writing
+        :return: fd to read from or write to. It is still maintained by this instance
+            and must not be closed directly
+        :raise IOError: if the lock could not be retrieved
+        :raise OSError: If the actual file could not be opened for reading
+
+        **note** must only be called once"""
+        if self._write is not None:
+            raise AssertionError("Called %s multiple times" % self.open)
+
+        self._write = write
+
+        # try to open the lock file
+        binary = getattr(os, 'O_BINARY', 0)
+        lockmode = os.O_WRONLY | os.O_CREAT | os.O_EXCL | binary
+        try:
+            fd = os.open(self._lockfilepath(), lockmode, int("600", 8))
+            if not write:
+                os.close(fd)
+            else:
+                self._fd = fd
+            # END handle file descriptor
+        except OSError as e:
+            raise IOError("Lock at %r could not be obtained" % self._lockfilepath()) from e
+        # END handle lock retrieval
+
+        # open actual file if required
+        if self._fd is None:
+            # we could specify exlusive here, as we obtained the lock anyway
+            try:
+                self._fd = os.open(self._filepath, os.O_RDONLY | binary)
+            except:
+                # assure we release our lockfile
+                remove(self._lockfilepath())
+                raise
+            # END handle lockfile
+        # END open descriptor for reading
+
+        if stream:
+            # need delayed import
+            from gitdb.stream import FDStream
+            return FDStream(self._fd)
+        else:
+            return self._fd
+        # END handle stream
+
+    def commit(self):
+        """When done writing, call this function to commit your changes into the
+        actual file.
+        The file descriptor will be closed, and the lockfile handled.
+
+        **Note** can be called multiple times"""
+        self._end_writing(successful=True)
+
+    def rollback(self):
+        """Abort your operation without any changes. The file descriptor will be
+        closed, and the lock released.
+
+        **Note** can be called multiple times"""
+        self._end_writing(successful=False)
+
+    def _end_writing(self, successful=True):
+        """Handle the lock according to the write mode """
+        if self._write is None:
+            raise AssertionError("Cannot end operation if it wasn't started yet")
+
+        if self._fd is None:
+            return
+
+        os.close(self._fd)
+        self._fd = None
+
+        lockfile = self._lockfilepath()
+        if self._write and successful:
+            # on windows, rename does not silently overwrite the existing one
+            if sys.platform == "win32":
+                if isfile(self._filepath):
+                    remove(self._filepath)
+                # END remove if exists
+            # END win32 special handling
+            os.rename(lockfile, self._filepath)
+
+            # assure others can at least read the file - the tmpfile left it at rw--
+            # We may also write that file, on windows that boils down to a remove-
+            # protection as well
+            chmod(self._filepath, int("644", 8))
+        else:
+            # just delete the file so far, we failed
+            remove(lockfile)
+        # END successful handling
+
+#} END utilities

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_proxy.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67f77a59361389216643d54c6f9bf38e83b4583cf45d1f96599af196e22db881
+size 113016

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5z.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99b3d967ef4ae35b57e6797e8079d43c71a0aa146fa76e592f2b05499905d4b9
+size 104872

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/_qhull.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a1dcc9c9db6d1bd1713b8d40b4b3211af3a7bb2be660e2740aba98aad37750d
+size 1935422