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

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

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