@tushar-br/desktop 1.0.283 → 1.0.284

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

@@ -1,326 +0,0 @@
-from __future__ import annotations
-
-import codecs
-import re
-
-from .structures import ImmutableList
-
-
-class Accept(ImmutableList):
-    """An :class:`Accept` object is just a list subclass for lists of
-    ``(value, quality)`` tuples.  It is automatically sorted by specificity
-    and quality.
-
-    All :class:`Accept` objects work similar to a list but provide extra
-    functionality for working with the data.  Containment checks are
-    normalized to the rules of that header:
-
-    >>> a = CharsetAccept([('ISO-8859-1', 1), ('utf-8', 0.7)])
-    >>> a.best
-    'ISO-8859-1'
-    >>> 'iso-8859-1' in a
-    True
-    >>> 'UTF8' in a
-    True
-    >>> 'utf7' in a
-    False
-
-    To get the quality for an item you can use normal item lookup:
-
-    >>> print a['utf-8']
-    0.7
-    >>> a['utf7']
-    0
-
-    .. versionchanged:: 0.5
-       :class:`Accept` objects are forced immutable now.
-
-    .. versionchanged:: 1.0.0
-       :class:`Accept` internal values are no longer ordered
-       alphabetically for equal quality tags. Instead the initial
-       order is preserved.
-
-    """
-
-    def __init__(self, values=()):
-        if values is None:
-            list.__init__(self)
-            self.provided = False
-        elif isinstance(values, Accept):
-            self.provided = values.provided
-            list.__init__(self, values)
-        else:
-            self.provided = True
-            values = sorted(
-                values, key=lambda x: (self._specificity(x[0]), x[1]), reverse=True
-            )
-            list.__init__(self, values)
-
-    def _specificity(self, value):
-        """Returns a tuple describing the value's specificity."""
-        return (value != "*",)
-
-    def _value_matches(self, value, item):
-        """Check if a value matches a given accept item."""
-        return item == "*" or item.lower() == value.lower()
-
-    def __getitem__(self, key):
-        """Besides index lookup (getting item n) you can also pass it a string
-        to get the quality for the item.  If the item is not in the list, the
-        returned quality is ``0``.
-        """
-        if isinstance(key, str):
-            return self.quality(key)
-        return list.__getitem__(self, key)
-
-    def quality(self, key):
-        """Returns the quality of the key.
-
-        .. versionadded:: 0.6
-           In previous versions you had to use the item-lookup syntax
-           (eg: ``obj[key]`` instead of ``obj.quality(key)``)
-        """
-        for item, quality in self:
-            if self._value_matches(key, item):
-                return quality
-        return 0
-
-    def __contains__(self, value):
-        for item, _quality in self:
-            if self._value_matches(value, item):
-                return True
-        return False
-
-    def __repr__(self):
-        pairs_str = ", ".join(f"({x!r}, {y})" for x, y in self)
-        return f"{type(self).__name__}([{pairs_str}])"
-
-    def index(self, key):
-        """Get the position of an entry or raise :exc:`ValueError`.
-
-        :param key: The key to be looked up.
-
-        .. versionchanged:: 0.5
-           This used to raise :exc:`IndexError`, which was inconsistent
-           with the list API.
-        """
-        if isinstance(key, str):
-            for idx, (item, _quality) in enumerate(self):
-                if self._value_matches(key, item):
-                    return idx
-            raise ValueError(key)
-        return list.index(self, key)
-
-    def find(self, key):
-        """Get the position of an entry or return -1.
-
-        :param key: The key to be looked up.
-        """
-        try:
-            return self.index(key)
-        except ValueError:
-            return -1
-
-    def values(self):
-        """Iterate over all values."""
-        for item in self:
-            yield item[0]
-
-    def to_header(self):
-        """Convert the header set into an HTTP header string."""
-        result = []
-        for value, quality in self:
-            if quality != 1:
-                value = f"{value};q={quality}"
-            result.append(value)
-        return ",".join(result)
-
-    def __str__(self):
-        return self.to_header()
-
-    def _best_single_match(self, match):
-        for client_item, quality in self:
-            if self._value_matches(match, client_item):
-                # self is sorted by specificity descending, we can exit
-                return client_item, quality
-        return None
-
-    def best_match(self, matches, default=None):
-        """Returns the best match from a list of possible matches based
-        on the specificity and quality of the client. If two items have the
-        same quality and specificity, the one is returned that comes first.
-
-        :param matches: a list of matches to check for
-        :param default: the value that is returned if none match
-        """
-        result = default
-        best_quality = -1
-        best_specificity = (-1,)
-        for server_item in matches:
-            match = self._best_single_match(server_item)
-            if not match:
-                continue
-            client_item, quality = match
-            specificity = self._specificity(client_item)
-            if quality <= 0 or quality < best_quality:
-                continue
-            # better quality or same quality but more specific => better match
-            if quality > best_quality or specificity > best_specificity:
-                result = server_item
-                best_quality = quality
-                best_specificity = specificity
-        return result
-
-    @property
-    def best(self):
-        """The best match as value."""
-        if self:
-            return self[0][0]
-
-
-_mime_split_re = re.compile(r"/|(?:\s*;\s*)")
-
-
-def _normalize_mime(value):
-    return _mime_split_re.split(value.lower())
-
-
-class MIMEAccept(Accept):
-    """Like :class:`Accept` but with special methods and behavior for
-    mimetypes.
-    """
-
-    def _specificity(self, value):
-        return tuple(x != "*" for x in _mime_split_re.split(value))
-
-    def _value_matches(self, value, item):
-        # item comes from the client, can't match if it's invalid.
-        if "/" not in item:
-            return False
-
-        # value comes from the application, tell the developer when it
-        # doesn't look valid.
-        if "/" not in value:
-            raise ValueError(f"invalid mimetype {value!r}")
-
-        # Split the match value into type, subtype, and a sorted list of parameters.
-        normalized_value = _normalize_mime(value)
-        value_type, value_subtype = normalized_value[:2]
-        value_params = sorted(normalized_value[2:])
-
-        # "*/*" is the only valid value that can start with "*".
-        if value_type == "*" and value_subtype != "*":
-            raise ValueError(f"invalid mimetype {value!r}")
-
-        # Split the accept item into type, subtype, and parameters.
-        normalized_item = _normalize_mime(item)
-        item_type, item_subtype = normalized_item[:2]
-        item_params = sorted(normalized_item[2:])
-
-        # "*/not-*" from the client is invalid, can't match.
-        if item_type == "*" and item_subtype != "*":
-            return False
-
-        return (
-            (item_type == "*" and item_subtype == "*")
-            or (value_type == "*" and value_subtype == "*")
-        ) or (
-            item_type == value_type
-            and (
-                item_subtype == "*"
-                or value_subtype == "*"
-                or (item_subtype == value_subtype and item_params == value_params)
-            )
-        )
-
-    @property
-    def accept_html(self):
-        """True if this object accepts HTML."""
-        return (
-            "text/html" in self or "application/xhtml+xml" in self or self.accept_xhtml
-        )
-
-    @property
-    def accept_xhtml(self):
-        """True if this object accepts XHTML."""
-        return "application/xhtml+xml" in self or "application/xml" in self
-
-    @property
-    def accept_json(self):
-        """True if this object accepts JSON."""
-        return "application/json" in self
-
-
-_locale_delim_re = re.compile(r"[_-]")
-
-
-def _normalize_lang(value):
-    """Process a language tag for matching."""
-    return _locale_delim_re.split(value.lower())
-
-
-class LanguageAccept(Accept):
-    """Like :class:`Accept` but with normalization for language tags."""
-
-    def _value_matches(self, value, item):
-        return item == "*" or _normalize_lang(value) == _normalize_lang(item)
-
-    def best_match(self, matches, default=None):
-        """Given a list of supported values, finds the best match from
-        the list of accepted values.
-
-        Language tags are normalized for the purpose of matching, but
-        are returned unchanged.
-
-        If no exact match is found, this will fall back to matching
-        the first subtag (primary language only), first with the
-        accepted values then with the match values. This partial is not
-        applied to any other language subtags.
-
-        The default is returned if no exact or fallback match is found.
-
-        :param matches: A list of supported languages to find a match.
-        :param default: The value that is returned if none match.
-        """
-        # Look for an exact match first. If a client accepts "en-US",
-        # "en-US" is a valid match at this point.
-        result = super().best_match(matches)
-
-        if result is not None:
-            return result
-
-        # Fall back to accepting primary tags. If a client accepts
-        # "en-US", "en" is a valid match at this point. Need to use
-        # re.split to account for 2 or 3 letter codes.
-        fallback = Accept(
-            [(_locale_delim_re.split(item[0], 1)[0], item[1]) for item in self]
-        )
-        result = fallback.best_match(matches)
-
-        if result is not None:
-            return result
-
-        # Fall back to matching primary tags. If the client accepts
-        # "en", "en-US" is a valid match at this point.
-        fallback_matches = [_locale_delim_re.split(item, 1)[0] for item in matches]
-        result = super().best_match(fallback_matches)
-
-        # Return a value from the original match list. Find the first
-        # original value that starts with the matched primary tag.
-        if result is not None:
-            return next(item for item in matches if item.startswith(result))
-
-        return default
-
-
-class CharsetAccept(Accept):
-    """Like :class:`Accept` but with normalization for charsets."""
-
-    def _value_matches(self, value, item):
-        def _normalize(name):
-            try:
-                return codecs.lookup(name).name
-            except LookupError:
-                return name.lower()
-
-        return item == "*" or _normalize(value) == _normalize(item)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/werkzeug/datastructures/accept.pyi

@@ -1,54 +0,0 @@
-from collections.abc import Iterable
-from collections.abc import Iterator
-from typing import overload
-
-from .structures import ImmutableList
-
-class Accept(ImmutableList[tuple[str, int]]):
-    provided: bool
-    def __init__(
-        self, values: Accept | Iterable[tuple[str, float]] | None = None
-    ) -> None: ...
-    def _specificity(self, value: str) -> tuple[bool, ...]: ...
-    def _value_matches(self, value: str, item: str) -> bool: ...
-    @overload  # type: ignore
-    def __getitem__(self, key: str) -> int: ...
-    @overload
-    def __getitem__(self, key: int) -> tuple[str, int]: ...
-    @overload
-    def __getitem__(self, key: slice) -> Iterable[tuple[str, int]]: ...
-    def quality(self, key: str) -> int: ...
-    def __contains__(self, value: str) -> bool: ...  # type: ignore
-    def index(self, key: str) -> int: ...  # type: ignore
-    def find(self, key: str) -> int: ...
-    def values(self) -> Iterator[str]: ...
-    def to_header(self) -> str: ...
-    def _best_single_match(self, match: str) -> tuple[str, int] | None: ...
-    @overload
-    def best_match(self, matches: Iterable[str], default: str) -> str: ...
-    @overload
-    def best_match(
-        self, matches: Iterable[str], default: str | None = None
-    ) -> str | None: ...
-    @property
-    def best(self) -> str: ...
-
-def _normalize_mime(value: str) -> list[str]: ...
-
-class MIMEAccept(Accept):
-    def _specificity(self, value: str) -> tuple[bool, ...]: ...
-    def _value_matches(self, value: str, item: str) -> bool: ...
-    @property
-    def accept_html(self) -> bool: ...
-    @property
-    def accept_xhtml(self) -> bool: ...
-    @property
-    def accept_json(self) -> bool: ...
-
-def _normalize_lang(value: str) -> list[str]: ...
-
-class LanguageAccept(Accept):
-    def _value_matches(self, value: str, item: str) -> bool: ...
-
-class CharsetAccept(Accept):
-    def _value_matches(self, value: str, item: str) -> bool: ...

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

@@ -1,318 +0,0 @@
-from __future__ import annotations
-
-import base64
-import binascii
-import typing as t
-
-from ..http import dump_header
-from ..http import parse_dict_header
-from ..http import quote_header_value
-from .structures import CallbackDict
-
-if t.TYPE_CHECKING:
-    import typing_extensions as te
-
-
-class Authorization:
-    """Represents the parts of an ``Authorization`` request header.
-
-    :attr:`.Request.authorization` returns an instance if the header is set.
-
-    An instance can be used with the test :class:`.Client` request methods' ``auth``
-    parameter to send the header in test requests.
-
-    Depending on the auth scheme, either :attr:`parameters` or :attr:`token` will be
-    set. The ``Basic`` scheme's token is decoded into the ``username`` and ``password``
-    parameters.
-
-    For convenience, ``auth["key"]`` and ``auth.key`` both access the key in the
-    :attr:`parameters` dict, along with ``auth.get("key")`` and ``"key" in auth``.
-
-    .. versionchanged:: 2.3
-        The ``token`` parameter and attribute was added to support auth schemes that use
-        a token instead of parameters, such as ``Bearer``.
-
-    .. versionchanged:: 2.3
-        The object is no longer a ``dict``.
-
-    .. versionchanged:: 0.5
-        The object is an immutable dict.
-    """
-
-    def __init__(
-        self,
-        auth_type: str,
-        data: dict[str, str | None] | None = None,
-        token: str | None = None,
-    ) -> None:
-        self.type = auth_type
-        """The authorization scheme, like ``basic``, ``digest``, or ``bearer``."""
-
-        if data is None:
-            data = {}
-
-        self.parameters = data
-        """A dict of parameters parsed from the header. Either this or :attr:`token`
-        will have a value for a given scheme.
-        """
-
-        self.token = token
-        """A token parsed from the header. Either this or :attr:`parameters` will have a
-        value for a given scheme.
-
-        .. versionadded:: 2.3
-        """
-
-    def __getattr__(self, name: str) -> str | None:
-        return self.parameters.get(name)
-
-    def __getitem__(self, name: str) -> str | None:
-        return self.parameters.get(name)
-
-    def get(self, key: str, default: str | None = None) -> str | None:
-        return self.parameters.get(key, default)
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.parameters
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Authorization):
-            return NotImplemented
-
-        return (
-            other.type == self.type
-            and other.token == self.token
-            and other.parameters == self.parameters
-        )
-
-    @classmethod
-    def from_header(cls, value: str | None) -> te.Self | None:
-        """Parse an ``Authorization`` header value and return an instance, or ``None``
-        if the value is empty.
-
-        :param value: The header value to parse.
-
-        .. versionadded:: 2.3
-        """
-        if not value:
-            return None
-
-        scheme, _, rest = value.partition(" ")
-        scheme = scheme.lower()
-        rest = rest.strip()
-
-        if scheme == "basic":
-            try:
-                username, _, password = base64.b64decode(rest).decode().partition(":")
-            except (binascii.Error, UnicodeError):
-                return None
-
-            return cls(scheme, {"username": username, "password": password})
-
-        if "=" in rest.rstrip("="):
-            # = that is not trailing, this is parameters.
-            return cls(scheme, parse_dict_header(rest), None)
-
-        # No = or only trailing =, this is a token.
-        return cls(scheme, None, rest)
-
-    def to_header(self) -> str:
-        """Produce an ``Authorization`` header value representing this data.
-
-        .. versionadded:: 2.0
-        """
-        if self.type == "basic":
-            value = base64.b64encode(
-                f"{self.username}:{self.password}".encode()
-            ).decode("utf8")
-            return f"Basic {value}"
-
-        if self.token is not None:
-            return f"{self.type.title()} {self.token}"
-
-        return f"{self.type.title()} {dump_header(self.parameters)}"
-
-    def __str__(self) -> str:
-        return self.to_header()
-
-    def __repr__(self) -> str:
-        return f"<{type(self).__name__} {self.to_header()}>"
-
-
-class WWWAuthenticate:
-    """Represents the parts of a ``WWW-Authenticate`` response header.
-
-    Set :attr:`.Response.www_authenticate` to an instance of list of instances to set
-    values for this header in the response. Modifying this instance will modify the
-    header value.
-
-    Depending on the auth scheme, either :attr:`parameters` or :attr:`token` should be
-    set. The ``Basic`` scheme will encode ``username`` and ``password`` parameters to a
-    token.
-
-    For convenience, ``auth["key"]`` and ``auth.key`` both act on the :attr:`parameters`
-    dict, and can be used to get, set, or delete parameters. ``auth.get("key")`` and
-    ``"key" in auth`` are also provided.
-
-    .. versionchanged:: 2.3
-        The ``token`` parameter and attribute was added to support auth schemes that use
-        a token instead of parameters, such as ``Bearer``.
-
-    .. versionchanged:: 2.3
-        The object is no longer a ``dict``.
-
-    .. versionchanged:: 2.3
-        The ``on_update`` parameter was removed.
-    """
-
-    def __init__(
-        self,
-        auth_type: str,
-        values: dict[str, str | None] | None = None,
-        token: str | None = None,
-    ):
-        self._type = auth_type.lower()
-        self._parameters: dict[str, str | None] = CallbackDict(  # type: ignore[misc]
-            values, lambda _: self._trigger_on_update()
-        )
-        self._token = token
-        self._on_update: t.Callable[[WWWAuthenticate], None] | None = None
-
-    def _trigger_on_update(self) -> None:
-        if self._on_update is not None:
-            self._on_update(self)
-
-    @property
-    def type(self) -> str:
-        """The authorization scheme, like ``basic``, ``digest``, or ``bearer``."""
-        return self._type
-
-    @type.setter
-    def type(self, value: str) -> None:
-        self._type = value
-        self._trigger_on_update()
-
-    @property
-    def parameters(self) -> dict[str, str | None]:
-        """A dict of parameters for the header. Only one of this or :attr:`token` should
-        have a value for a given scheme.
-        """
-        return self._parameters
-
-    @parameters.setter
-    def parameters(self, value: dict[str, str]) -> None:
-        self._parameters = CallbackDict(  # type: ignore[misc]
-            value, lambda _: self._trigger_on_update()
-        )
-        self._trigger_on_update()
-
-    @property
-    def token(self) -> str | None:
-        """A dict of parameters for the header. Only one of this or :attr:`token` should
-        have a value for a given scheme.
-        """
-        return self._token
-
-    @token.setter
-    def token(self, value: str | None) -> None:
-        """A token for the header. Only one of this or :attr:`parameters` should have a
-        value for a given scheme.
-
-        .. versionadded:: 2.3
-        """
-        self._token = value
-        self._trigger_on_update()
-
-    def __getitem__(self, key: str) -> str | None:
-        return self.parameters.get(key)
-
-    def __setitem__(self, key: str, value: str | None) -> None:
-        if value is None:
-            if key in self.parameters:
-                del self.parameters[key]
-        else:
-            self.parameters[key] = value
-
-        self._trigger_on_update()
-
-    def __delitem__(self, key: str) -> None:
-        if key in self.parameters:
-            del self.parameters[key]
-            self._trigger_on_update()
-
-    def __getattr__(self, name: str) -> str | None:
-        return self[name]
-
-    def __setattr__(self, name: str, value: str | None) -> None:
-        if name in {"_type", "_parameters", "_token", "_on_update"}:
-            super().__setattr__(name, value)
-        else:
-            self[name] = value
-
-    def __delattr__(self, name: str) -> None:
-        del self[name]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.parameters
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, WWWAuthenticate):
-            return NotImplemented
-
-        return (
-            other.type == self.type
-            and other.token == self.token
-            and other.parameters == self.parameters
-        )
-
-    def get(self, key: str, default: str | None = None) -> str | None:
-        return self.parameters.get(key, default)
-
-    @classmethod
-    def from_header(cls, value: str | None) -> te.Self | None:
-        """Parse a ``WWW-Authenticate`` header value and return an instance, or ``None``
-        if the value is empty.
-
-        :param value: The header value to parse.
-
-        .. versionadded:: 2.3
-        """
-        if not value:
-            return None
-
-        scheme, _, rest = value.partition(" ")
-        scheme = scheme.lower()
-        rest = rest.strip()
-
-        if "=" in rest.rstrip("="):
-            # = that is not trailing, this is parameters.
-            return cls(scheme, parse_dict_header(rest), None)
-
-        # No = or only trailing =, this is a token.
-        return cls(scheme, None, rest)
-
-    def to_header(self) -> str:
-        """Produce a ``WWW-Authenticate`` header value representing this data."""
-        if self.token is not None:
-            return f"{self.type.title()} {self.token}"
-
-        if self.type == "digest":
-            items = []
-
-            for key, value in self.parameters.items():
-                if key in {"realm", "domain", "nonce", "opaque", "qop"}:
-                    value = quote_header_value(value, allow_token=False)
-                else:
-                    value = quote_header_value(value)
-
-                items.append(f"{key}={value}")
-
-            return f"Digest {', '.join(items)}"
-
-        return f"{self.type.title()} {dump_header(self.parameters)}"
-
-    def __str__(self) -> str:
-        return self.to_header()
-
-    def __repr__(self) -> str:
-        return f"<{type(self).__name__} {self.to_header()}>"