@tushar-br/desktop 1.0.282 → 1.0.283

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

@@ -0,0 +1,326 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,318 @@
+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()}>"