@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/sansio/utils.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-
-import typing as t
-from urllib.parse import quote
-
-from .._internal import _plain_int
-from ..exceptions import SecurityError
-from ..urls import uri_to_iri
-
-
-def host_is_trusted(hostname: str, trusted_list: t.Iterable[str]) -> bool:
-    """Check if a host matches a list of trusted names.
-
-    :param hostname: The name to check.
-    :param trusted_list: A list of valid names to match. If a name
-        starts with a dot it will match all subdomains.
-
-    .. versionadded:: 0.9
-    """
-    if not hostname:
-        return False
-
-    try:
-        hostname = hostname.partition(":")[0].encode("idna").decode("ascii")
-    except UnicodeEncodeError:
-        return False
-
-    if isinstance(trusted_list, str):
-        trusted_list = [trusted_list]
-
-    for ref in trusted_list:
-        if ref.startswith("."):
-            ref = ref[1:]
-            suffix_match = True
-        else:
-            suffix_match = False
-
-        try:
-            ref = ref.partition(":")[0].encode("idna").decode("ascii")
-        except UnicodeEncodeError:
-            return False
-
-        if ref == hostname or (suffix_match and hostname.endswith(f".{ref}")):
-            return True
-
-    return False
-
-
-def get_host(
-    scheme: str,
-    host_header: str | None,
-    server: tuple[str, int | None] | None = None,
-    trusted_hosts: t.Iterable[str] | None = None,
-) -> str:
-    """Return the host for the given parameters.
-
-    This first checks the ``host_header``. If it's not present, then
-    ``server`` is used. The host will only contain the port if it is
-    different than the standard port for the protocol.
-
-    Optionally, verify that the host is trusted using
-    :func:`host_is_trusted` and raise a
-    :exc:`~werkzeug.exceptions.SecurityError` if it is not.
-
-    :param scheme: The protocol the request used, like ``"https"``.
-    :param host_header: The ``Host`` header value.
-    :param server: Address of the server. ``(host, port)``, or
-        ``(path, None)`` for unix sockets.
-    :param trusted_hosts: A list of trusted host names.
-
-    :return: Host, with port if necessary.
-    :raise ~werkzeug.exceptions.SecurityError: If the host is not
-        trusted.
-    """
-    host = ""
-
-    if host_header is not None:
-        host = host_header
-    elif server is not None:
-        host = server[0]
-
-        if server[1] is not None:
-            host = f"{host}:{server[1]}"
-
-    if scheme in {"http", "ws"} and host.endswith(":80"):
-        host = host[:-3]
-    elif scheme in {"https", "wss"} and host.endswith(":443"):
-        host = host[:-4]
-
-    if trusted_hosts is not None:
-        if not host_is_trusted(host, trusted_hosts):
-            raise SecurityError(f"Host {host!r} is not trusted.")
-
-    return host
-
-
-def get_current_url(
-    scheme: str,
-    host: str,
-    root_path: str | None = None,
-    path: str | None = None,
-    query_string: bytes | None = None,
-) -> str:
-    """Recreate the URL for a request. If an optional part isn't
-    provided, it and subsequent parts are not included in the URL.
-
-    The URL is an IRI, not a URI, so it may contain Unicode characters.
-    Use :func:`~werkzeug.urls.iri_to_uri` to convert it to ASCII.
-
-    :param scheme: The protocol the request used, like ``"https"``.
-    :param host: The host the request was made to. See :func:`get_host`.
-    :param root_path: Prefix that the application is mounted under. This
-        is prepended to ``path``.
-    :param path: The path part of the URL after ``root_path``.
-    :param query_string: The portion of the URL after the "?".
-    """
-    url = [scheme, "://", host]
-
-    if root_path is None:
-        url.append("/")
-        return uri_to_iri("".join(url))
-
-    # safe = https://url.spec.whatwg.org/#url-path-segment-string
-    # as well as percent for things that are already quoted
-    url.append(quote(root_path.rstrip("/"), safe="!$&'()*+,/:;=@%"))
-    url.append("/")
-
-    if path is None:
-        return uri_to_iri("".join(url))
-
-    url.append(quote(path.lstrip("/"), safe="!$&'()*+,/:;=@%"))
-
-    if query_string:
-        url.append("?")
-        url.append(quote(query_string, safe="!$&'()*+,/:;=?@%"))
-
-    return uri_to_iri("".join(url))
-
-
-def get_content_length(
-    http_content_length: str | None = None,
-    http_transfer_encoding: str | None = None,
-) -> int | None:
-    """Return the ``Content-Length`` header value as an int. If the header is not given
-    or the ``Transfer-Encoding`` header is ``chunked``, ``None`` is returned to indicate
-    a streaming request. If the value is not an integer, or negative, 0 is returned.
-
-    :param http_content_length: The Content-Length HTTP header.
-    :param http_transfer_encoding: The Transfer-Encoding HTTP header.
-
-    .. versionadded:: 2.2
-    """
-    if http_transfer_encoding == "chunked" or http_content_length is None:
-        return None
-
-    try:
-        return max(0, _plain_int(http_content_length))
-    except ValueError:
-        return 0

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

@@ -1,157 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import hmac
-import os
-import posixpath
-import secrets
-
-SALT_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-DEFAULT_PBKDF2_ITERATIONS = 600000
-
-_os_alt_seps: list[str] = list(
-    sep for sep in [os.sep, os.path.altsep] if sep is not None and sep != "/"
-)
-
-
-def gen_salt(length: int) -> str:
-    """Generate a random string of SALT_CHARS with specified ``length``."""
-    if length <= 0:
-        raise ValueError("Salt length must be at least 1.")
-
-    return "".join(secrets.choice(SALT_CHARS) for _ in range(length))
-
-
-def _hash_internal(method: str, salt: str, password: str) -> tuple[str, str]:
-    method, *args = method.split(":")
-    salt = salt.encode("utf-8")
-    password = password.encode("utf-8")
-
-    if method == "scrypt":
-        if not args:
-            n = 2**15
-            r = 8
-            p = 1
-        else:
-            try:
-                n, r, p = map(int, args)
-            except ValueError:
-                raise ValueError("'scrypt' takes 3 arguments.") from None
-
-        maxmem = 132 * n * r * p  # ideally 128, but some extra seems needed
-        return (
-            hashlib.scrypt(password, salt=salt, n=n, r=r, p=p, maxmem=maxmem).hex(),
-            f"scrypt:{n}:{r}:{p}",
-        )
-    elif method == "pbkdf2":
-        len_args = len(args)
-
-        if len_args == 0:
-            hash_name = "sha256"
-            iterations = DEFAULT_PBKDF2_ITERATIONS
-        elif len_args == 1:
-            hash_name = args[0]
-            iterations = DEFAULT_PBKDF2_ITERATIONS
-        elif len_args == 2:
-            hash_name = args[0]
-            iterations = int(args[1])
-        else:
-            raise ValueError("'pbkdf2' takes 2 arguments.")
-
-        return (
-            hashlib.pbkdf2_hmac(hash_name, password, salt, iterations).hex(),
-            f"pbkdf2:{hash_name}:{iterations}",
-        )
-    else:
-        raise ValueError(f"Invalid hash method '{method}'.")
-
-
-def generate_password_hash(
-    password: str, method: str = "scrypt", salt_length: int = 16
-) -> str:
-    """Securely hash a password for storage. A password can be compared to a stored hash
-    using :func:`check_password_hash`.
-
-    The following methods are supported:
-
-    -   ``scrypt``, the default. The parameters are ``n``, ``r``, and ``p``, the default
-        is ``scrypt:32768:8:1``. See :func:`hashlib.scrypt`.
-    -   ``pbkdf2``, less secure. The parameters are ``hash_method`` and ``iterations``,
-        the default is ``pbkdf2:sha256:600000``. See :func:`hashlib.pbkdf2_hmac`.
-
-    Default parameters may be updated to reflect current guidelines, and methods may be
-    deprecated and removed if they are no longer considered secure. To migrate old
-    hashes, you may generate a new hash when checking an old hash, or you may contact
-    users with a link to reset their password.
-
-    :param password: The plaintext password.
-    :param method: The key derivation function and parameters.
-    :param salt_length: The number of characters to generate for the salt.
-
-    .. versionchanged:: 2.3
-        Scrypt support was added.
-
-    .. versionchanged:: 2.3
-        The default iterations for pbkdf2 was increased to 600,000.
-
-    .. versionchanged:: 2.3
-        All plain hashes are deprecated and will not be supported in Werkzeug 3.0.
-    """
-    salt = gen_salt(salt_length)
-    h, actual_method = _hash_internal(method, salt, password)
-    return f"{actual_method}${salt}${h}"
-
-
-def check_password_hash(pwhash: str, password: str) -> bool:
-    """Securely check that the given stored password hash, previously generated using
-    :func:`generate_password_hash`, matches the given password.
-
-    Methods may be deprecated and removed if they are no longer considered secure. To
-    migrate old hashes, you may generate a new hash when checking an old hash, or you
-    may contact users with a link to reset their password.
-
-    :param pwhash: The hashed password.
-    :param password: The plaintext password.
-
-    .. versionchanged:: 2.3
-        All plain hashes are deprecated and will not be supported in Werkzeug 3.0.
-    """
-    try:
-        method, salt, hashval = pwhash.split("$", 2)
-    except ValueError:
-        return False
-
-    return hmac.compare_digest(_hash_internal(method, salt, password)[0], hashval)
-
-
-def safe_join(directory: str, *pathnames: str) -> str | None:
-    """Safely join zero or more untrusted path components to a base
-    directory to avoid escaping the base directory.
-
-    :param directory: The trusted base directory.
-    :param pathnames: The untrusted path components relative to the
-        base directory.
-    :return: A safe path, otherwise ``None``.
-    """
-    if not directory:
-        # Ensure we end up with ./path if directory="" is given,
-        # otherwise the first untrusted part could become trusted.
-        directory = "."
-
-    parts = [directory]
-
-    for filename in pathnames:
-        if filename != "":
-            filename = posixpath.normpath(filename)
-
-        if (
-            any(sep in filename for sep in _os_alt_seps)
-            or os.path.isabs(filename)
-            or filename == ".."
-            or filename.startswith("../")
-        ):
-            return None
-
-        parts.append(filename)
-
-    return posixpath.join(*parts)