npm - @tushar-br/desktop - Versions diffs - 1.0.283 → 1.0.284 - Mend

@tushar-br/desktop 1.0.283 → 1.0.284

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of @tushar-br/desktop might be problematic. Click here for more details.

Files changed (3797) hide show

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/websockets/datastructures.py DELETED Viewed

@@ -1,183 +0,0 @@
-from __future__ import annotations
-from collections.abc import Iterable, Iterator, Mapping, MutableMapping
-from typing import Any, Protocol
-__all__ = [
-    "Headers",
-    "HeadersLike",
-    "MultipleValuesError",
-]
-class MultipleValuesError(LookupError):
-    """
-    Exception raised when :class:`Headers` has multiple values for a key.
-    """
-    def __str__(self) -> str:
-        # Implement the same logic as KeyError_str in Objects/exceptions.c.
-        if len(self.args) == 1:
-            return repr(self.args[0])
-        return super().__str__()
-class Headers(MutableMapping[str, str]):
-    """
-    Efficient data structure for manipulating HTTP headers.
-    A :class:`list` of ``(name, values)`` is inefficient for lookups.
-    A :class:`dict` doesn't suffice because header names are case-insensitive
-    and multiple occurrences of headers with the same name are possible.
-    :class:`Headers` stores HTTP headers in a hybrid data structure to provide
-    efficient insertions and lookups while preserving the original data.
-    In order to account for multiple values with minimal hassle,
-    :class:`Headers` follows this logic:
-    - When getting a header with ``headers[name]``:
-        - if there's no value, :exc:`KeyError` is raised;
-        - if there's exactly one value, it's returned;
-        - if there's more than one value, :exc:`MultipleValuesError` is raised.
-    - When setting a header with ``headers[name] = value``, the value is
-      appended to the list of values for that header.
-    - When deleting a header with ``del headers[name]``, all values for that
-      header are removed (this is slow).
-    Other methods for manipulating headers are consistent with this logic.
-    As long as no header occurs multiple times, :class:`Headers` behaves like
-    :class:`dict`, except keys are lower-cased to provide case-insensitivity.
-    Two methods support manipulating multiple values explicitly:
-    - :meth:`get_all` returns a list of all values for a header;
-    - :meth:`raw_items` returns an iterator of ``(name, values)`` pairs.
-    """
-    __slots__ = ["_dict", "_list"]
-    # Like dict, Headers accepts an optional "mapping or iterable" argument.
-    def __init__(self, *args: HeadersLike, **kwargs: str) -> None:
-        self._dict: dict[str, list[str]] = {}
-        self._list: list[tuple[str, str]] = []
-        self.update(*args, **kwargs)
-    def __str__(self) -> str:
-        return "".join(f"{key}: {value}\r\n" for key, value in self._list) + "\r\n"
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self._list!r})"
-    def copy(self) -> Headers:
-        copy = self.__class__()
-        copy._dict = self._dict.copy()
-        copy._list = self._list.copy()
-        return copy
-    def serialize(self) -> bytes:
-        # Since headers only contain ASCII characters, we can keep this simple.
-        return str(self).encode()
-    # Collection methods
-    def __contains__(self, key: object) -> bool:
-        return isinstance(key, str) and key.lower() in self._dict
-    def __iter__(self) -> Iterator[str]:
-        return iter(self._dict)
-    def __len__(self) -> int:
-        return len(self._dict)
-    # MutableMapping methods
-    def __getitem__(self, key: str) -> str:
-        value = self._dict[key.lower()]
-        if len(value) == 1:
-            return value[0]
-        else:
-            raise MultipleValuesError(key)
-    def __setitem__(self, key: str, value: str) -> None:
-        self._dict.setdefault(key.lower(), []).append(value)
-        self._list.append((key, value))
-    def __delitem__(self, key: str) -> None:
-        key_lower = key.lower()
-        self._dict.__delitem__(key_lower)
-        # This is inefficient. Fortunately deleting HTTP headers is uncommon.
-        self._list = [(k, v) for k, v in self._list if k.lower() != key_lower]
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Headers):
-            return NotImplemented
-        return self._dict == other._dict
-    def clear(self) -> None:
-        """
-        Remove all headers.
-        """
-        self._dict = {}
-        self._list = []
-    def update(self, *args: HeadersLike, **kwargs: str) -> None:
-        """
-        Update from a :class:`Headers` instance and/or keyword arguments.
-        """
-        args = tuple(
-            arg.raw_items() if isinstance(arg, Headers) else arg for arg in args
-        )
-        super().update(*args, **kwargs)
-    # Methods for handling multiple values
-    def get_all(self, key: str) -> list[str]:
-        """
-        Return the (possibly empty) list of all values for a header.
-        Args:
-            key: Header name.
-        """
-        return self._dict.get(key.lower(), [])
-    def raw_items(self) -> Iterator[tuple[str, str]]:
-        """
-        Return an iterator of all values as ``(name, value)`` pairs.
-        """
-        return iter(self._list)
-# copy of _typeshed.SupportsKeysAndGetItem.
-class SupportsKeysAndGetItem(Protocol):  # pragma: no cover
-    """
-    Dict-like types with ``keys() -> str`` and ``__getitem__(key: str) -> str`` methods.
-    """
-    def keys(self) -> Iterable[str]: ...
-    def __getitem__(self, key: str) -> str: ...
-HeadersLike = (
-    Headers | Mapping[str, str] | Iterable[tuple[str, str]] | SupportsKeysAndGetItem
-)
-"""
-Types accepted where :class:`Headers` is expected.
-In addition to :class:`Headers` itself, this includes dict-like types where both
-keys and values are :class:`str`.
-"""

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/websockets/exceptions.py DELETED Viewed

@@ -1,473 +0,0 @@
-"""
-:mod:`websockets.exceptions` defines the following hierarchy of exceptions.
-* :exc:`WebSocketException`
-    * :exc:`ConnectionClosed`
-        * :exc:`ConnectionClosedOK`
-        * :exc:`ConnectionClosedError`
-    * :exc:`InvalidURI`
-    * :exc:`InvalidProxy`
-    * :exc:`InvalidHandshake`
-        * :exc:`SecurityError`
-        * :exc:`ProxyError`
-            * :exc:`InvalidProxyMessage`
-            * :exc:`InvalidProxyStatus`
-        * :exc:`InvalidMessage`
-        * :exc:`InvalidStatus`
-        * :exc:`InvalidStatusCode` (legacy)
-        * :exc:`InvalidHeader`
-            * :exc:`InvalidHeaderFormat`
-            * :exc:`InvalidHeaderValue`
-            * :exc:`InvalidOrigin`
-            * :exc:`InvalidUpgrade`
-        * :exc:`NegotiationError`
-            * :exc:`DuplicateParameter`
-            * :exc:`InvalidParameterName`
-            * :exc:`InvalidParameterValue`
-        * :exc:`AbortHandshake` (legacy)
-        * :exc:`RedirectHandshake` (legacy)
-    * :exc:`ProtocolError` (Sans-I/O)
-    * :exc:`PayloadTooBig` (Sans-I/O)
-    * :exc:`InvalidState` (Sans-I/O)
-    * :exc:`ConcurrencyError`
-"""
-from __future__ import annotations
-import warnings
-from .imports import lazy_import
-__all__ = [
-    "WebSocketException",
-    "ConnectionClosed",
-    "ConnectionClosedOK",
-    "ConnectionClosedError",
-    "InvalidURI",
-    "InvalidProxy",
-    "InvalidHandshake",
-    "SecurityError",
-    "ProxyError",
-    "InvalidProxyMessage",
-    "InvalidProxyStatus",
-    "InvalidMessage",
-    "InvalidStatus",
-    "InvalidHeader",
-    "InvalidHeaderFormat",
-    "InvalidHeaderValue",
-    "InvalidOrigin",
-    "InvalidUpgrade",
-    "NegotiationError",
-    "DuplicateParameter",
-    "InvalidParameterName",
-    "InvalidParameterValue",
-    "ProtocolError",
-    "PayloadTooBig",
-    "InvalidState",
-    "ConcurrencyError",
-]
-class WebSocketException(Exception):
-    """
-    Base class for all exceptions defined by websockets.
-    """
-class ConnectionClosed(WebSocketException):
-    """
-    Raised when trying to interact with a closed connection.
-    Attributes:
-        rcvd: If a close frame was received, its code and reason are available
-            in ``rcvd.code`` and ``rcvd.reason``.
-        sent: If a close frame was sent, its code and reason are available
-            in ``sent.code`` and ``sent.reason``.
-        rcvd_then_sent: If close frames were received and sent, this attribute
-            tells in which order this happened, from the perspective of this
-            side of the connection.
-    """
-    def __init__(
-        self,
-        rcvd: frames.Close | None,
-        sent: frames.Close | None,
-        rcvd_then_sent: bool | None = None,
-    ) -> None:
-        self.rcvd = rcvd
-        self.sent = sent
-        self.rcvd_then_sent = rcvd_then_sent
-        assert (self.rcvd_then_sent is None) == (self.rcvd is None or self.sent is None)
-    def __str__(self) -> str:
-        if self.rcvd is None:
-            if self.sent is None:
-                return "no close frame received or sent"
-            else:
-                return f"sent {self.sent}; no close frame received"
-        else:
-            if self.sent is None:
-                return f"received {self.rcvd}; no close frame sent"
-            else:
-                if self.rcvd_then_sent:
-                    return f"received {self.rcvd}; then sent {self.sent}"
-                else:
-                    return f"sent {self.sent}; then received {self.rcvd}"
-    # code and reason attributes are provided for backwards-compatibility
-    @property
-    def code(self) -> int:
-        warnings.warn(  # deprecated in 13.1 - 2024-09-21
-            "ConnectionClosed.code is deprecated; "
-            "use Protocol.close_code or ConnectionClosed.rcvd.code",
-            DeprecationWarning,
-        )
-        if self.rcvd is None:
-            return frames.CloseCode.ABNORMAL_CLOSURE
-        return self.rcvd.code
-    @property
-    def reason(self) -> str:
-        warnings.warn(  # deprecated in 13.1 - 2024-09-21
-            "ConnectionClosed.reason is deprecated; "
-            "use Protocol.close_reason or ConnectionClosed.rcvd.reason",
-            DeprecationWarning,
-        )
-        if self.rcvd is None:
-            return ""
-        return self.rcvd.reason
-class ConnectionClosedOK(ConnectionClosed):
-    """
-    Like :exc:`ConnectionClosed`, when the connection terminated properly.
-    A close code with code 1000 (OK) or 1001 (going away) or without a code was
-    received and sent.
-    """
-class ConnectionClosedError(ConnectionClosed):
-    """
-    Like :exc:`ConnectionClosed`, when the connection terminated with an error.
-    A close frame with a code other than 1000 (OK) or 1001 (going away) was
-    received or sent, or the closing handshake didn't complete properly.
-    """
-class InvalidURI(WebSocketException):
-    """
-    Raised when connecting to a URI that isn't a valid WebSocket URI.
-    """
-    def __init__(self, uri: str, msg: str) -> None:
-        self.uri = uri
-        self.msg = msg
-    def __str__(self) -> str:
-        return f"{self.uri} isn't a valid URI: {self.msg}"
-class InvalidProxy(WebSocketException):
-    """
-    Raised when connecting via a proxy that isn't valid.
-    """
-    def __init__(self, proxy: str, msg: str) -> None:
-        self.proxy = proxy
-        self.msg = msg
-    def __str__(self) -> str:
-        return f"{self.proxy} isn't a valid proxy: {self.msg}"
-class InvalidHandshake(WebSocketException):
-    """
-    Base class for exceptions raised when the opening handshake fails.
-    """
-class SecurityError(InvalidHandshake):
-    """
-    Raised when a handshake request or response breaks a security rule.
-    Security limits can be configured with :doc:`environment variables
-    <../reference/variables>`.
-    """
-class ProxyError(InvalidHandshake):
-    """
-    Raised when failing to connect to a proxy.
-    """
-class InvalidProxyMessage(ProxyError):
-    """
-    Raised when an HTTP proxy response is malformed.
-    """
-class InvalidProxyStatus(ProxyError):
-    """
-    Raised when an HTTP proxy rejects the connection.
-    """
-    def __init__(self, response: http11.Response) -> None:
-        self.response = response
-    def __str__(self) -> str:
-        return f"proxy rejected connection: HTTP {self.response.status_code:d}"
-class InvalidMessage(InvalidHandshake):
-    """
-    Raised when a handshake request or response is malformed.
-    """
-class InvalidStatus(InvalidHandshake):
-    """
-    Raised when a handshake response rejects the WebSocket upgrade.
-    """
-    def __init__(self, response: http11.Response) -> None:
-        self.response = response
-    def __str__(self) -> str:
-        return (
-            f"server rejected WebSocket connection: HTTP {self.response.status_code:d}"
-        )
-class InvalidHeader(InvalidHandshake):
-    """
-    Raised when an HTTP header doesn't have a valid format or value.
-    """
-    def __init__(self, name: str, value: str | None = None) -> None:
-        self.name = name
-        self.value = value
-    def __str__(self) -> str:
-        if self.value is None:
-            return f"missing {self.name} header"
-        elif self.value == "":
-            return f"empty {self.name} header"
-        else:
-            return f"invalid {self.name} header: {self.value}"
-class InvalidHeaderFormat(InvalidHeader):
-    """
-    Raised when an HTTP header cannot be parsed.
-    The format of the header doesn't match the grammar for that header.
-    """
-    def __init__(self, name: str, error: str, header: str, pos: int) -> None:
-        super().__init__(name, f"{error} at {pos} in {header}")
-class InvalidHeaderValue(InvalidHeader):
-    """
-    Raised when an HTTP header has a wrong value.
-    The format of the header is correct but the value isn't acceptable.
-    """
-class InvalidOrigin(InvalidHeader):
-    """
-    Raised when the Origin header in a request isn't allowed.
-    """
-    def __init__(self, origin: str | None) -> None:
-        super().__init__("Origin", origin)
-class InvalidUpgrade(InvalidHeader):
-    """
-    Raised when the Upgrade or Connection header isn't correct.
-    """
-class NegotiationError(InvalidHandshake):
-    """
-    Raised when negotiating an extension or a subprotocol fails.
-    """
-class DuplicateParameter(NegotiationError):
-    """
-    Raised when a parameter name is repeated in an extension header.
-    """
-    def __init__(self, name: str) -> None:
-        self.name = name
-    def __str__(self) -> str:
-        return f"duplicate parameter: {self.name}"
-class InvalidParameterName(NegotiationError):
-    """
-    Raised when a parameter name in an extension header is invalid.
-    """
-    def __init__(self, name: str) -> None:
-        self.name = name
-    def __str__(self) -> str:
-        return f"invalid parameter name: {self.name}"
-class InvalidParameterValue(NegotiationError):
-    """
-    Raised when a parameter value in an extension header is invalid.
-    """
-    def __init__(self, name: str, value: str | None) -> None:
-        self.name = name
-        self.value = value
-    def __str__(self) -> str:
-        if self.value is None:
-            return f"missing value for parameter {self.name}"
-        elif self.value == "":
-            return f"empty value for parameter {self.name}"
-        else:
-            return f"invalid value for parameter {self.name}: {self.value}"
-class ProtocolError(WebSocketException):
-    """
-    Raised when receiving or sending a frame that breaks the protocol.
-    The Sans-I/O implementation raises this exception when:
-    * receiving or sending a frame that contains invalid data;
-    * receiving or sending an invalid sequence of frames.
-    """
-class PayloadTooBig(WebSocketException):
-    """
-    Raised when parsing a frame with a payload that exceeds the maximum size.
-    The Sans-I/O layer uses this exception internally. It doesn't bubble up to
-    the I/O layer.
-    The :meth:`~websockets.extensions.Extension.decode` method of extensions
-    must raise :exc:`PayloadTooBig` if decoding a frame would exceed the limit.
-    """
-    def __init__(
-        self,
-        size_or_message: int | None | str,
-        max_size: int | None = None,
-        current_size: int | None = None,
-    ) -> None:
-        if isinstance(size_or_message, str):
-            assert max_size is None
-            assert current_size is None
-            warnings.warn(  # deprecated in 14.0 - 2024-11-09
-                "PayloadTooBig(message) is deprecated; "
-                "change to PayloadTooBig(size, max_size)",
-                DeprecationWarning,
-            )
-            self.message: str | None = size_or_message
-        else:
-            self.message = None
-            self.size: int | None = size_or_message
-            assert max_size is not None
-            self.max_size: int = max_size
-            self.current_size: int | None = None
-            self.set_current_size(current_size)
-    def __str__(self) -> str:
-        if self.message is not None:
-            return self.message
-        else:
-            message = "frame "
-            if self.size is not None:
-                message += f"with {self.size} bytes "
-            if self.current_size is not None:
-                message += f"after reading {self.current_size} bytes "
-            message += f"exceeds limit of {self.max_size} bytes"
-            return message
-    def set_current_size(self, current_size: int | None) -> None:
-        assert self.current_size is None
-        if current_size is not None:
-            self.max_size += current_size
-            self.current_size = current_size
-class InvalidState(WebSocketException, AssertionError):
-    """
-    Raised when sending a frame is forbidden in the current state.
-    Specifically, the Sans-I/O layer raises this exception when:
-    * sending a data frame to a connection in a state other
-      :attr:`~websockets.protocol.State.OPEN`;
-    * sending a control frame to a connection in a state other than
-      :attr:`~websockets.protocol.State.OPEN` or
-      :attr:`~websockets.protocol.State.CLOSING`.
-    """
-class ConcurrencyError(WebSocketException, RuntimeError):
-    """
-    Raised when receiving or sending messages concurrently.
-    WebSocket is a connection-oriented protocol. Reads must be serialized; so
-    must be writes. However, reading and writing concurrently is possible.
-    """
-# At the bottom to break import cycles created by type annotations.
-from . import frames, http11  # noqa: E402
-lazy_import(
-    globals(),
-    deprecated_aliases={
-        # deprecated in 14.0 - 2024-11-09
-        "AbortHandshake": ".legacy.exceptions",
-        "InvalidStatusCode": ".legacy.exceptions",
-        "RedirectHandshake": ".legacy.exceptions",
-        "WebSocketProtocolError": ".legacy.exceptions",
-    },
-)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/websockets/extensions/__init__.py DELETED Viewed

@@ -1,4 +0,0 @@
-from .base import *
-__all__ = ["Extension", "ClientExtensionFactory", "ServerExtensionFactory"]

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/websockets/extensions/__pycache__/__init__.cpython-314.pyc DELETED Viewed

Binary file