catocli 1.0.13__py3-none-any.whl → 1.0.15__py3-none-any.whl

build/lib/vendor/urllib3/contrib/emscripten/__init__.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-import sys
-sys.path.insert(0, 'vendor')
-import urllib3.connection
-
-from ...connectionpool import HTTPConnectionPool, HTTPSConnectionPool
-from .connection import EmscriptenHTTPConnection, EmscriptenHTTPSConnection
-
-
-def inject_into_urllib3() -> None:
-    # override connection classes to use emscripten specific classes
-    # n.b. mypy complains about the overriding of classes below
-    # if it isn't ignored
-    HTTPConnectionPool.ConnectionCls = EmscriptenHTTPConnection
-    HTTPSConnectionPool.ConnectionCls = EmscriptenHTTPSConnection
-    urllib3.connection.HTTPConnection = EmscriptenHTTPConnection  # type: ignore[misc,assignment]
-    urllib3.connection.HTTPSConnection = EmscriptenHTTPSConnection  # type: ignore[misc,assignment]

build/lib/vendor/urllib3/contrib/emscripten/connection.py

@@ -1,254 +0,0 @@
-from __future__ import annotations
-
-import os
-import typing
-
-# use http.client.HTTPException for consistency with non-emscripten
-from http.client import HTTPException as HTTPException  # noqa: F401
-from http.client import ResponseNotReady
-
-from ..._base_connection import _TYPE_BODY
-from ...connection import HTTPConnection, ProxyConfig, port_by_scheme
-from ...exceptions import TimeoutError
-from ...response import BaseHTTPResponse
-from ...util.connection import _TYPE_SOCKET_OPTIONS
-from ...util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
-from ...util.url import Url
-from .fetch import _RequestError, _TimeoutError, send_request, send_streaming_request
-from .request import EmscriptenRequest
-from .response import EmscriptenHttpResponseWrapper, EmscriptenResponse
-
-if typing.TYPE_CHECKING:
-    from ..._base_connection import BaseHTTPConnection, BaseHTTPSConnection
-
-
-class EmscriptenHTTPConnection:
-    default_port: typing.ClassVar[int] = port_by_scheme["http"]
-    default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
-
-    timeout: None | (float)
-
-    host: str
-    port: int
-    blocksize: int
-    source_address: tuple[str, int] | None
-    socket_options: _TYPE_SOCKET_OPTIONS | None
-
-    proxy: Url | None
-    proxy_config: ProxyConfig | None
-
-    is_verified: bool = False
-    proxy_is_verified: bool | None = None
-
-    _response: EmscriptenResponse | None
-
-    def __init__(
-        self,
-        host: str,
-        port: int = 0,
-        *,
-        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
-        source_address: tuple[str, int] | None = None,
-        blocksize: int = 8192,
-        socket_options: _TYPE_SOCKET_OPTIONS | None = None,
-        proxy: Url | None = None,
-        proxy_config: ProxyConfig | None = None,
-    ) -> None:
-        self.host = host
-        self.port = port
-        self.timeout = timeout if isinstance(timeout, float) else 0.0
-        self.scheme = "http"
-        self._closed = True
-        self._response = None
-        # ignore these things because we don't
-        # have control over that stuff
-        self.proxy = None
-        self.proxy_config = None
-        self.blocksize = blocksize
-        self.source_address = None
-        self.socket_options = None
-        self.is_verified = False
-
-    def set_tunnel(
-        self,
-        host: str,
-        port: int | None = 0,
-        headers: typing.Mapping[str, str] | None = None,
-        scheme: str = "http",
-    ) -> None:
-        pass
-
-    def connect(self) -> None:
-        pass
-
-    def request(
-        self,
-        method: str,
-        url: str,
-        body: _TYPE_BODY | None = None,
-        headers: typing.Mapping[str, str] | None = None,
-        # We know *at least* botocore is depending on the order of the
-        # first 3 parameters so to be safe we only mark the later ones
-        # as keyword-only to ensure we have space to extend.
-        *,
-        chunked: bool = False,
-        preload_content: bool = True,
-        decode_content: bool = True,
-        enforce_content_length: bool = True,
-    ) -> None:
-        self._closed = False
-        if url.startswith("/"):
-            # no scheme / host / port included, make a full url
-            url = f"{self.scheme}://{self.host}:{self.port}" + url
-        request = EmscriptenRequest(
-            url=url,
-            method=method,
-            timeout=self.timeout if self.timeout else 0,
-            decode_content=decode_content,
-        )
-        request.set_body(body)
-        if headers:
-            for k, v in headers.items():
-                request.set_header(k, v)
-        self._response = None
-        try:
-            if not preload_content:
-                self._response = send_streaming_request(request)
-            if self._response is None:
-                self._response = send_request(request)
-        except _TimeoutError as e:
-            raise TimeoutError(e.message) from e
-        except _RequestError as e:
-            raise HTTPException(e.message) from e
-
-    def getresponse(self) -> BaseHTTPResponse:
-        if self._response is not None:
-            return EmscriptenHttpResponseWrapper(
-                internal_response=self._response,
-                url=self._response.request.url,
-                connection=self,
-            )
-        else:
-            raise ResponseNotReady()
-
-    def close(self) -> None:
-        self._closed = True
-        self._response = None
-
-    @property
-    def is_closed(self) -> bool:
-        """Whether the connection either is brand new or has been previously closed.
-        If this property is True then both ``is_connected`` and ``has_connected_to_proxy``
-        properties must be False.
-        """
-        return self._closed
-
-    @property
-    def is_connected(self) -> bool:
-        """Whether the connection is actively connected to any origin (proxy or target)"""
-        return True
-
-    @property
-    def has_connected_to_proxy(self) -> bool:
-        """Whether the connection has successfully connected to its proxy.
-        This returns False if no proxy is in use. Used to determine whether
-        errors are coming from the proxy layer or from tunnelling to the target origin.
-        """
-        return False
-
-
-class EmscriptenHTTPSConnection(EmscriptenHTTPConnection):
-    default_port = port_by_scheme["https"]
-    # all this is basically ignored, as browser handles https
-    cert_reqs: int | str | None = None
-    ca_certs: str | None = None
-    ca_cert_dir: str | None = None
-    ca_cert_data: None | str | bytes = None
-    cert_file: str | None
-    key_file: str | None
-    key_password: str | None
-    ssl_context: typing.Any | None
-    ssl_version: int | str | None = None
-    ssl_minimum_version: int | None = None
-    ssl_maximum_version: int | None = None
-    assert_hostname: None | str | typing.Literal[False]
-    assert_fingerprint: str | None = None
-
-    def __init__(
-        self,
-        host: str,
-        port: int = 0,
-        *,
-        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
-        source_address: tuple[str, int] | None = None,
-        blocksize: int = 16384,
-        socket_options: None
-        | _TYPE_SOCKET_OPTIONS = HTTPConnection.default_socket_options,
-        proxy: Url | None = None,
-        proxy_config: ProxyConfig | None = None,
-        cert_reqs: int | str | None = None,
-        assert_hostname: None | str | typing.Literal[False] = None,
-        assert_fingerprint: str | None = None,
-        server_hostname: str | None = None,
-        ssl_context: typing.Any | None = None,
-        ca_certs: str | None = None,
-        ca_cert_dir: str | None = None,
-        ca_cert_data: None | str | bytes = None,
-        ssl_minimum_version: int | None = None,
-        ssl_maximum_version: int | None = None,
-        ssl_version: int | str | None = None,  # Deprecated
-        cert_file: str | None = None,
-        key_file: str | None = None,
-        key_password: str | None = None,
-    ) -> None:
-        super().__init__(
-            host,
-            port=port,
-            timeout=timeout,
-            source_address=source_address,
-            blocksize=blocksize,
-            socket_options=socket_options,
-            proxy=proxy,
-            proxy_config=proxy_config,
-        )
-        self.scheme = "https"
-
-        self.key_file = key_file
-        self.cert_file = cert_file
-        self.key_password = key_password
-        self.ssl_context = ssl_context
-        self.server_hostname = server_hostname
-        self.assert_hostname = assert_hostname
-        self.assert_fingerprint = assert_fingerprint
-        self.ssl_version = ssl_version
-        self.ssl_minimum_version = ssl_minimum_version
-        self.ssl_maximum_version = ssl_maximum_version
-        self.ca_certs = ca_certs and os.path.expanduser(ca_certs)
-        self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)
-        self.ca_cert_data = ca_cert_data
-
-        self.cert_reqs = None
-
-        # The browser will automatically verify all requests.
-        # We have no control over that setting.
-        self.is_verified = True
-
-    def set_cert(
-        self,
-        key_file: str | None = None,
-        cert_file: str | None = None,
-        cert_reqs: int | str | None = None,
-        key_password: str | None = None,
-        ca_certs: str | None = None,
-        assert_hostname: None | str | typing.Literal[False] = None,
-        assert_fingerprint: str | None = None,
-        ca_cert_dir: str | None = None,
-        ca_cert_data: None | str | bytes = None,
-    ) -> None:
-        pass
-
-
-# verify that this class implements BaseHTTP(s) connection correctly
-if typing.TYPE_CHECKING:
-    _supports_http_protocol: BaseHTTPConnection = EmscriptenHTTPConnection("", 0)
-    _supports_https_protocol: BaseHTTPSConnection = EmscriptenHTTPSConnection("", 0)

build/lib/vendor/urllib3/contrib/emscripten/fetch.py

@@ -1,418 +0,0 @@
-"""
-Support for streaming http requests in emscripten.
-
-A few caveats -
-
-Firstly, you can't do streaming http in the main UI thread, because atomics.wait isn't allowed.
-Streaming only works if you're running pyodide in a web worker.
-
-Secondly, this uses an extra web worker and SharedArrayBuffer to do the asynchronous fetch
-operation, so it requires that you have crossOriginIsolation enabled, by serving over https
-(or from localhost) with the two headers below set:
-
-    Cross-Origin-Opener-Policy: same-origin
-    Cross-Origin-Embedder-Policy: require-corp
-
-You can tell if cross origin isolation is successfully enabled by looking at the global crossOriginIsolated variable in
-javascript console. If it isn't, streaming requests will fallback to XMLHttpRequest, i.e. getting the whole
-request into a buffer and then returning it. it shows a warning in the javascript console in this case.
-
-Finally, the webworker which does the streaming fetch is created on initial import, but will only be started once
-control is returned to javascript. Call `await wait_for_streaming_ready()` to wait for streaming fetch.
-
-NB: in this code, there are a lot of javascript objects. They are named js_*
-to make it clear what type of object they are.
-"""
-from __future__ import annotations
-
-import io
-import json
-from email.parser import Parser
-from importlib.resources import files
-from typing import TYPE_CHECKING, Any
-
-import js  # type: ignore[import-not-found]
-from pyodide.ffi import (  # type: ignore[import-not-found]
-    JsArray,
-    JsException,
-    JsProxy,
-    to_js,
-)
-
-if TYPE_CHECKING:
-    from typing_extensions import Buffer
-
-from .request import EmscriptenRequest
-from .response import EmscriptenResponse
-
-"""
-There are some headers that trigger unintended CORS preflight requests.
-See also https://github.com/koenvo/pyodide-http/issues/22
-"""
-HEADERS_TO_IGNORE = ("user-agent",)
-
-SUCCESS_HEADER = -1
-SUCCESS_EOF = -2
-ERROR_TIMEOUT = -3
-ERROR_EXCEPTION = -4
-
-_STREAMING_WORKER_CODE = (
-    files(__package__)
-    .joinpath("emscripten_fetch_worker.js")
-    .read_text(encoding="utf-8")
-)
-
-
-class _RequestError(Exception):
-    def __init__(
-        self,
-        message: str | None = None,
-        *,
-        request: EmscriptenRequest | None = None,
-        response: EmscriptenResponse | None = None,
-    ):
-        self.request = request
-        self.response = response
-        self.message = message
-        super().__init__(self.message)
-
-
-class _StreamingError(_RequestError):
-    pass
-
-
-class _TimeoutError(_RequestError):
-    pass
-
-
-def _obj_from_dict(dict_val: dict[str, Any]) -> JsProxy:
-    return to_js(dict_val, dict_converter=js.Object.fromEntries)
-
-
-class _ReadStream(io.RawIOBase):
-    def __init__(
-        self,
-        int_buffer: JsArray,
-        byte_buffer: JsArray,
-        timeout: float,
-        worker: JsProxy,
-        connection_id: int,
-        request: EmscriptenRequest,
-    ):
-        self.int_buffer = int_buffer
-        self.byte_buffer = byte_buffer
-        self.read_pos = 0
-        self.read_len = 0
-        self.connection_id = connection_id
-        self.worker = worker
-        self.timeout = int(1000 * timeout) if timeout > 0 else None
-        self.is_live = True
-        self._is_closed = False
-        self.request: EmscriptenRequest | None = request
-
-    def __del__(self) -> None:
-        self.close()
-
-    # this is compatible with _base_connection
-    def is_closed(self) -> bool:
-        return self._is_closed
-
-    # for compatibility with RawIOBase
-    @property
-    def closed(self) -> bool:
-        return self.is_closed()
-
-    def close(self) -> None:
-        if not self.is_closed():
-            self.read_len = 0
-            self.read_pos = 0
-            self.int_buffer = None
-            self.byte_buffer = None
-            self._is_closed = True
-            self.request = None
-            if self.is_live:
-                self.worker.postMessage(_obj_from_dict({"close": self.connection_id}))
-                self.is_live = False
-            super().close()
-
-    def readable(self) -> bool:
-        return True
-
-    def writable(self) -> bool:
-        return False
-
-    def seekable(self) -> bool:
-        return False
-
-    def readinto(self, byte_obj: Buffer) -> int:
-        if not self.int_buffer:
-            raise _StreamingError(
-                "No buffer for stream in _ReadStream.readinto",
-                request=self.request,
-                response=None,
-            )
-        if self.read_len == 0:
-            # wait for the worker to send something
-            js.Atomics.store(self.int_buffer, 0, ERROR_TIMEOUT)
-            self.worker.postMessage(_obj_from_dict({"getMore": self.connection_id}))
-            if (
-                js.Atomics.wait(self.int_buffer, 0, ERROR_TIMEOUT, self.timeout)
-                == "timed-out"
-            ):
-                raise _TimeoutError
-            data_len = self.int_buffer[0]
-            if data_len > 0:
-                self.read_len = data_len
-                self.read_pos = 0
-            elif data_len == ERROR_EXCEPTION:
-                string_len = self.int_buffer[1]
-                # decode the error string
-                js_decoder = js.TextDecoder.new()
-                json_str = js_decoder.decode(self.byte_buffer.slice(0, string_len))
-                raise _StreamingError(
-                    f"Exception thrown in fetch: {json_str}",
-                    request=self.request,
-                    response=None,
-                )
-            else:
-                # EOF, free the buffers and return zero
-                # and free the request
-                self.is_live = False
-                self.close()
-                return 0
-        # copy from int32array to python bytes
-        ret_length = min(self.read_len, len(memoryview(byte_obj)))
-        subarray = self.byte_buffer.subarray(
-            self.read_pos, self.read_pos + ret_length
-        ).to_py()
-        memoryview(byte_obj)[0:ret_length] = subarray
-        self.read_len -= ret_length
-        self.read_pos += ret_length
-        return ret_length
-
-
-class _StreamingFetcher:
-    def __init__(self) -> None:
-        # make web-worker and data buffer on startup
-        self.streaming_ready = False
-
-        js_data_blob = js.Blob.new(
-            [_STREAMING_WORKER_CODE], _obj_from_dict({"type": "application/javascript"})
-        )
-
-        def promise_resolver(js_resolve_fn: JsProxy, js_reject_fn: JsProxy) -> None:
-            def onMsg(e: JsProxy) -> None:
-                self.streaming_ready = True
-                js_resolve_fn(e)
-
-            def onErr(e: JsProxy) -> None:
-                js_reject_fn(e)  # Defensive: never happens in ci
-
-            self.js_worker.onmessage = onMsg
-            self.js_worker.onerror = onErr
-
-        js_data_url = js.URL.createObjectURL(js_data_blob)
-        self.js_worker = js.globalThis.Worker.new(js_data_url)
-        self.js_worker_ready_promise = js.globalThis.Promise.new(promise_resolver)
-
-    def send(self, request: EmscriptenRequest) -> EmscriptenResponse:
-        headers = {
-            k: v for k, v in request.headers.items() if k not in HEADERS_TO_IGNORE
-        }
-
-        body = request.body
-        fetch_data = {"headers": headers, "body": to_js(body), "method": request.method}
-        # start the request off in the worker
-        timeout = int(1000 * request.timeout) if request.timeout > 0 else None
-        js_shared_buffer = js.SharedArrayBuffer.new(1048576)
-        js_int_buffer = js.Int32Array.new(js_shared_buffer)
-        js_byte_buffer = js.Uint8Array.new(js_shared_buffer, 8)
-
-        js.Atomics.store(js_int_buffer, 0, ERROR_TIMEOUT)
-        js.Atomics.notify(js_int_buffer, 0)
-        js_absolute_url = js.URL.new(request.url, js.location).href
-        self.js_worker.postMessage(
-            _obj_from_dict(
-                {
-                    "buffer": js_shared_buffer,
-                    "url": js_absolute_url,
-                    "fetchParams": fetch_data,
-                }
-            )
-        )
-        # wait for the worker to send something
-        js.Atomics.wait(js_int_buffer, 0, ERROR_TIMEOUT, timeout)
-        if js_int_buffer[0] == ERROR_TIMEOUT:
-            raise _TimeoutError(
-                "Timeout connecting to streaming request",
-                request=request,
-                response=None,
-            )
-        elif js_int_buffer[0] == SUCCESS_HEADER:
-            # got response
-            # header length is in second int of intBuffer
-            string_len = js_int_buffer[1]
-            # decode the rest to a JSON string
-            js_decoder = js.TextDecoder.new()
-            # this does a copy (the slice) because decode can't work on shared array
-            # for some silly reason
-            json_str = js_decoder.decode(js_byte_buffer.slice(0, string_len))
-            # get it as an object
-            response_obj = json.loads(json_str)
-            return EmscriptenResponse(
-                request=request,
-                status_code=response_obj["status"],
-                headers=response_obj["headers"],
-                body=_ReadStream(
-                    js_int_buffer,
-                    js_byte_buffer,
-                    request.timeout,
-                    self.js_worker,
-                    response_obj["connectionID"],
-                    request,
-                ),
-            )
-        elif js_int_buffer[0] == ERROR_EXCEPTION:
-            string_len = js_int_buffer[1]
-            # decode the error string
-            js_decoder = js.TextDecoder.new()
-            json_str = js_decoder.decode(js_byte_buffer.slice(0, string_len))
-            raise _StreamingError(
-                f"Exception thrown in fetch: {json_str}", request=request, response=None
-            )
-        else:
-            raise _StreamingError(
-                f"Unknown status from worker in fetch: {js_int_buffer[0]}",
-                request=request,
-                response=None,
-            )
-
-
-# check if we are in a worker or not
-def is_in_browser_main_thread() -> bool:
-    return hasattr(js, "window") and hasattr(js, "self") and js.self == js.window
-
-
-def is_cross_origin_isolated() -> bool:
-    return hasattr(js, "crossOriginIsolated") and js.crossOriginIsolated
-
-
-def is_in_node() -> bool:
-    return (
-        hasattr(js, "process")
-        and hasattr(js.process, "release")
-        and hasattr(js.process.release, "name")
-        and js.process.release.name == "node"
-    )
-
-
-def is_worker_available() -> bool:
-    return hasattr(js, "Worker") and hasattr(js, "Blob")
-
-
-_fetcher: _StreamingFetcher | None = None
-
-if is_worker_available() and (
-    (is_cross_origin_isolated() and not is_in_browser_main_thread())
-    and (not is_in_node())
-):
-    _fetcher = _StreamingFetcher()
-else:
-    _fetcher = None
-
-
-def send_streaming_request(request: EmscriptenRequest) -> EmscriptenResponse | None:
-    if _fetcher and streaming_ready():
-        return _fetcher.send(request)
-    else:
-        _show_streaming_warning()
-        return None
-
-
-_SHOWN_TIMEOUT_WARNING = False
-
-
-def _show_timeout_warning() -> None:
-    global _SHOWN_TIMEOUT_WARNING
-    if not _SHOWN_TIMEOUT_WARNING:
-        _SHOWN_TIMEOUT_WARNING = True
-        message = "Warning: Timeout is not available on main browser thread"
-        js.console.warn(message)
-
-
-_SHOWN_STREAMING_WARNING = False
-
-
-def _show_streaming_warning() -> None:
-    global _SHOWN_STREAMING_WARNING
-    if not _SHOWN_STREAMING_WARNING:
-        _SHOWN_STREAMING_WARNING = True
-        message = "Can't stream HTTP requests because: \n"
-        if not is_cross_origin_isolated():
-            message += "  Page is not cross-origin isolated\n"
-        if is_in_browser_main_thread():
-            message += "  Python is running in main browser thread\n"
-        if not is_worker_available():
-            message += " Worker or Blob classes are not available in this environment."  # Defensive: this is always False in browsers that we test in
-        if streaming_ready() is False:
-            message += """ Streaming fetch worker isn't ready. If you want to be sure that streaming fetch
-is working, you need to call: 'await urllib3.contrib.emscripten.fetch.wait_for_streaming_ready()`"""
-        from js import console
-
-        console.warn(message)
-
-
-def send_request(request: EmscriptenRequest) -> EmscriptenResponse:
-    try:
-        js_xhr = js.XMLHttpRequest.new()
-
-        if not is_in_browser_main_thread():
-            js_xhr.responseType = "arraybuffer"
-            if request.timeout:
-                js_xhr.timeout = int(request.timeout * 1000)
-        else:
-            js_xhr.overrideMimeType("text/plain; charset=ISO-8859-15")
-            if request.timeout:
-                # timeout isn't available on the main thread - show a warning in console
-                # if it is set
-                _show_timeout_warning()
-
-        js_xhr.open(request.method, request.url, False)
-        for name, value in request.headers.items():
-            if name.lower() not in HEADERS_TO_IGNORE:
-                js_xhr.setRequestHeader(name, value)
-
-        js_xhr.send(to_js(request.body))
-
-        headers = dict(Parser().parsestr(js_xhr.getAllResponseHeaders()))
-
-        if not is_in_browser_main_thread():
-            body = js_xhr.response.to_py().tobytes()
-        else:
-            body = js_xhr.response.encode("ISO-8859-15")
-        return EmscriptenResponse(
-            status_code=js_xhr.status, headers=headers, body=body, request=request
-        )
-    except JsException as err:
-        if err.name == "TimeoutError":
-            raise _TimeoutError(err.message, request=request)
-        elif err.name == "NetworkError":
-            raise _RequestError(err.message, request=request)
-        else:
-            # general http error
-            raise _RequestError(err.message, request=request)
-
-
-def streaming_ready() -> bool | None:
-    if _fetcher:
-        return _fetcher.streaming_ready
-    else:
-        return None  # no fetcher, return None to signify that
-
-
-async def wait_for_streaming_ready() -> bool:
-    if _fetcher:
-        await _fetcher.js_worker_ready_promise
-        return True
-    else:
-        return False