@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/pip/_internal/utils/packaging.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import functools
-import logging
-
-from pip._vendor.packaging import specifiers, version
-from pip._vendor.packaging.requirements import Requirement
-
-logger = logging.getLogger(__name__)
-
-
-@functools.lru_cache(maxsize=32)
-def check_requires_python(
-    requires_python: str | None, version_info: tuple[int, ...]
-) -> bool:
-    """
-    Check if the given Python version matches a "Requires-Python" specifier.
-
-    :param version_info: A 3-tuple of ints representing a Python
-        major-minor-micro version to check (e.g. `sys.version_info[:3]`).
-
-    :return: `True` if the given Python version satisfies the requirement.
-        Otherwise, return `False`.
-
-    :raises InvalidSpecifier: If `requires_python` has an invalid format.
-    """
-    if requires_python is None:
-        # The package provides no information
-        return True
-    requires_python_specifier = specifiers.SpecifierSet(requires_python)
-
-    python_version = version.parse(".".join(map(str, version_info)))
-    return python_version in requires_python_specifier
-
-
-@functools.lru_cache(maxsize=10000)
-def get_requirement(req_string: str) -> Requirement:
-    """Construct a packaging.Requirement object with caching"""
-    # Parsing requirement strings is expensive, and is also expected to happen
-    # with a low diversity of different arguments (at least relative the number
-    # constructed). This method adds a cache to requirement object creation to
-    # minimize repeated parsing of the same string to construct equivalent
-    # Requirement objects.
-    return Requirement(req_string)

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

@@ -1,116 +0,0 @@
-from collections.abc import Iterable
-from pathlib import Path
-
-from pip._vendor.packaging.pylock import (
-    Package,
-    PackageArchive,
-    PackageDirectory,
-    PackageSdist,
-    PackageVcs,
-    PackageWheel,
-    Pylock,
-)
-from pip._vendor.packaging.version import Version
-
-from pip._internal.models.direct_url import ArchiveInfo, DirInfo, VcsInfo
-from pip._internal.models.link import Link
-from pip._internal.req.req_install import InstallRequirement
-from pip._internal.utils.urls import url_to_path
-
-
-def _pylock_package_from_install_requirement(
-    ireq: InstallRequirement, base_dir: Path
-) -> Package:
-    base_dir = base_dir.resolve()
-    dist = ireq.get_dist()
-    download_info = ireq.download_info
-    assert download_info
-    package_version = None
-    package_vcs = None
-    package_directory = None
-    package_archive = None
-    package_sdist = None
-    package_wheels = None
-    if ireq.is_direct:
-        if isinstance(download_info.info, VcsInfo):
-            package_vcs = PackageVcs(
-                type=download_info.info.vcs,
-                url=download_info.url,
-                path=None,
-                requested_revision=download_info.info.requested_revision,
-                commit_id=download_info.info.commit_id,
-                subdirectory=download_info.subdirectory,
-            )
-        elif isinstance(download_info.info, DirInfo):
-            package_directory = PackageDirectory(
-                path=(
-                    Path(url_to_path(download_info.url))
-                    .resolve()
-                    .relative_to(base_dir)
-                    .as_posix()
-                ),
-                editable=(
-                    download_info.info.editable if download_info.info.editable else None
-                ),
-                subdirectory=download_info.subdirectory,
-            )
-        elif isinstance(download_info.info, ArchiveInfo):
-            if not download_info.info.hashes:
-                raise NotImplementedError()
-            package_archive = PackageArchive(
-                url=download_info.url,
-                path=None,
-                hashes=download_info.info.hashes,
-                subdirectory=download_info.subdirectory,
-            )
-        else:
-            # should never happen
-            raise NotImplementedError()
-    else:
-        package_version = dist.version
-        if isinstance(download_info.info, ArchiveInfo):
-            if not download_info.info.hashes:
-                raise NotImplementedError()
-            link = Link(download_info.url)
-            if link.is_wheel:
-                package_wheels = [
-                    PackageWheel(
-                        name=link.filename,
-                        url=download_info.url,
-                        hashes=download_info.info.hashes,
-                    )
-                ]
-            else:
-                package_sdist = PackageSdist(
-                    name=link.filename,
-                    url=download_info.url,
-                    hashes=download_info.info.hashes,
-                )
-        else:
-            # should never happen
-            raise NotImplementedError()
-    return Package(
-        name=dist.canonical_name,
-        version=package_version,
-        vcs=package_vcs,
-        directory=package_directory,
-        archive=package_archive,
-        sdist=package_sdist,
-        wheels=package_wheels,
-    )
-
-
-def pylock_from_install_requirements(
-    install_requirements: Iterable[InstallRequirement], base_dir: Path
-) -> Pylock:
-    return Pylock(
-        lock_version=Version("1.0"),
-        created_by="pip",
-        packages=sorted(
-            (
-                _pylock_package_from_install_requirement(ireq, base_dir)
-                for ireq in install_requirements
-            ),
-            key=lambda p: p.name,
-        ),
-    )

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

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-import functools
-from time import perf_counter, sleep
-from typing import TYPE_CHECKING, Callable, TypeVar
-
-if TYPE_CHECKING:
-    from typing_extensions import ParamSpec
-
-    T = TypeVar("T")
-    P = ParamSpec("P")
-
-
-def retry(
-    wait: float, stop_after_delay: float
-) -> Callable[[Callable[P, T]], Callable[P, T]]:
-    """Decorator to automatically retry a function on error.
-
-    If the function raises, the function is recalled with the same arguments
-    until it returns or the time limit is reached. When the time limit is
-    surpassed, the last exception raised is reraised.
-
-    :param wait: The time to wait after an error before retrying, in seconds.
-    :param stop_after_delay: The time limit after which retries will cease,
-        in seconds.
-    """
-
-    def wrapper(func: Callable[P, T]) -> Callable[P, T]:
-
-        @functools.wraps(func)
-        def retry_wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
-            # The performance counter is monotonic on all platforms we care
-            # about and has much better resolution than time.monotonic().
-            start_time = perf_counter()
-            while True:
-                try:
-                    return func(*args, **kwargs)
-                except Exception:
-                    if perf_counter() - start_time > stop_after_delay:
-                        raise
-                    sleep(wait)
-
-        return retry_wrapped
-
-    return wrapper

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

@@ -1,248 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import shlex
-import subprocess
-from collections.abc import Iterable, Mapping
-from typing import Any, Callable, Literal, Union
-
-from pip._vendor.rich.markup import escape
-
-from pip._internal.cli.spinners import SpinnerInterface, open_spinner
-from pip._internal.exceptions import InstallationSubprocessError
-from pip._internal.utils.logging import VERBOSE, subprocess_logger
-from pip._internal.utils.misc import HiddenText
-
-CommandArgs = list[Union[str, HiddenText]]
-
-
-def make_command(*args: str | HiddenText | CommandArgs) -> CommandArgs:
-    """
-    Create a CommandArgs object.
-    """
-    command_args: CommandArgs = []
-    for arg in args:
-        # Check for list instead of CommandArgs since CommandArgs is
-        # only known during type-checking.
-        if isinstance(arg, list):
-            command_args.extend(arg)
-        else:
-            # Otherwise, arg is str or HiddenText.
-            command_args.append(arg)
-
-    return command_args
-
-
-def format_command_args(args: list[str] | CommandArgs) -> str:
-    """
-    Format command arguments for display.
-    """
-    # For HiddenText arguments, display the redacted form by calling str().
-    # Also, we don't apply str() to arguments that aren't HiddenText since
-    # this can trigger a UnicodeDecodeError in Python 2 if the argument
-    # has type unicode and includes a non-ascii character.  (The type
-    # checker doesn't ensure the annotations are correct in all cases.)
-    return " ".join(
-        shlex.quote(str(arg)) if isinstance(arg, HiddenText) else shlex.quote(arg)
-        for arg in args
-    )
-
-
-def reveal_command_args(args: list[str] | CommandArgs) -> list[str]:
-    """
-    Return the arguments in their raw, unredacted form.
-    """
-    return [arg.secret if isinstance(arg, HiddenText) else arg for arg in args]
-
-
-def call_subprocess(
-    cmd: list[str] | CommandArgs,
-    show_stdout: bool = False,
-    cwd: str | None = None,
-    on_returncode: Literal["raise", "warn", "ignore"] = "raise",
-    extra_ok_returncodes: Iterable[int] | None = None,
-    extra_environ: Mapping[str, Any] | None = None,
-    unset_environ: Iterable[str] | None = None,
-    spinner: SpinnerInterface | None = None,
-    log_failed_cmd: bool | None = True,
-    stdout_only: bool | None = False,
-    *,
-    command_desc: str,
-) -> str:
-    """
-    Args:
-      show_stdout: if true, use INFO to log the subprocess's stderr and
-        stdout streams.  Otherwise, use DEBUG.  Defaults to False.
-      extra_ok_returncodes: an iterable of integer return codes that are
-        acceptable, in addition to 0. Defaults to None, which means [].
-      unset_environ: an iterable of environment variable names to unset
-        prior to calling subprocess.Popen().
-      log_failed_cmd: if false, failed commands are not logged, only raised.
-      stdout_only: if true, return only stdout, else return both. When true,
-        logging of both stdout and stderr occurs when the subprocess has
-        terminated, else logging occurs as subprocess output is produced.
-    """
-    if extra_ok_returncodes is None:
-        extra_ok_returncodes = []
-    if unset_environ is None:
-        unset_environ = []
-    # Most places in pip use show_stdout=False. What this means is--
-    #
-    # - We connect the child's output (combined stderr and stdout) to a
-    #   single pipe, which we read.
-    # - We log this output to stderr at DEBUG level as it is received.
-    # - If DEBUG logging isn't enabled (e.g. if --verbose logging wasn't
-    #   requested), then we show a spinner so the user can still see the
-    #   subprocess is in progress.
-    # - If the subprocess exits with an error, we log the output to stderr
-    #   at ERROR level if it hasn't already been displayed to the console
-    #   (e.g. if --verbose logging wasn't enabled).  This way we don't log
-    #   the output to the console twice.
-    #
-    # If show_stdout=True, then the above is still done, but with DEBUG
-    # replaced by INFO.
-    if show_stdout:
-        # Then log the subprocess output at INFO level.
-        log_subprocess: Callable[..., None] = subprocess_logger.info
-        used_level = logging.INFO
-    else:
-        # Then log the subprocess output using VERBOSE.  This also ensures
-        # it will be logged to the log file (aka user_log), if enabled.
-        log_subprocess = subprocess_logger.verbose
-        used_level = VERBOSE
-
-    # Whether the subprocess will be visible in the console.
-    showing_subprocess = subprocess_logger.getEffectiveLevel() <= used_level
-
-    # Only use the spinner if we're not showing the subprocess output
-    # and we have a spinner.
-    use_spinner = not showing_subprocess and spinner is not None
-
-    log_subprocess("Running command %s", command_desc)
-    env = os.environ.copy()
-    if extra_environ:
-        env.update(extra_environ)
-    for name in unset_environ:
-        env.pop(name, None)
-    try:
-        proc = subprocess.Popen(
-            # Convert HiddenText objects to the underlying str.
-            reveal_command_args(cmd),
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT if not stdout_only else subprocess.PIPE,
-            cwd=cwd,
-            env=env,
-            errors="backslashreplace",
-        )
-    except Exception as exc:
-        if log_failed_cmd:
-            subprocess_logger.critical(
-                "Error %s while executing command %s",
-                exc,
-                command_desc,
-            )
-        raise
-    all_output = []
-    if not stdout_only:
-        assert proc.stdout
-        assert proc.stdin
-        proc.stdin.close()
-        # In this mode, stdout and stderr are in the same pipe.
-        while True:
-            line: str = proc.stdout.readline()
-            if not line:
-                break
-            line = line.rstrip()
-            all_output.append(line + "\n")
-
-            # Show the line immediately.
-            log_subprocess(line)
-            # Update the spinner.
-            if use_spinner:
-                assert spinner
-                spinner.spin()
-        try:
-            proc.wait()
-        finally:
-            if proc.stdout:
-                proc.stdout.close()
-        output = "".join(all_output)
-    else:
-        # In this mode, stdout and stderr are in different pipes.
-        # We must use communicate() which is the only safe way to read both.
-        out, err = proc.communicate()
-        # log line by line to preserve pip log indenting
-        for out_line in out.splitlines():
-            log_subprocess(out_line)
-        all_output.append(out)
-        for err_line in err.splitlines():
-            log_subprocess(err_line)
-        all_output.append(err)
-        output = out
-
-    proc_had_error = proc.returncode and proc.returncode not in extra_ok_returncodes
-    if use_spinner:
-        assert spinner
-        if proc_had_error:
-            spinner.finish("error")
-        else:
-            spinner.finish("done")
-    if proc_had_error:
-        if on_returncode == "raise":
-            error = InstallationSubprocessError(
-                command_description=command_desc,
-                exit_code=proc.returncode,
-                output_lines=all_output if not showing_subprocess else None,
-            )
-            if log_failed_cmd:
-                subprocess_logger.error("%s", error, extra={"rich": True})
-                subprocess_logger.verbose(
-                    "[bold magenta]full command[/]: [blue]%s[/]",
-                    escape(format_command_args(cmd)),
-                    extra={"markup": True},
-                )
-                subprocess_logger.verbose(
-                    "[bold magenta]cwd[/]: %s",
-                    escape(cwd or "[inherit]"),
-                    extra={"markup": True},
-                )
-
-            raise error
-        elif on_returncode == "warn":
-            subprocess_logger.warning(
-                'Command "%s" had error code %s in %s',
-                command_desc,
-                proc.returncode,
-                cwd,
-            )
-        elif on_returncode == "ignore":
-            pass
-        else:
-            raise ValueError(f"Invalid value: on_returncode={on_returncode!r}")
-    return output
-
-
-def runner_with_spinner_message(message: str) -> Callable[..., None]:
-    """Provide a subprocess_runner that shows a spinner message.
-
-    Intended for use with for BuildBackendHookCaller. Thus, the runner has
-    an API that matches what's expected by BuildBackendHookCaller.subprocess_runner.
-    """
-
-    def runner(
-        cmd: list[str],
-        cwd: str | None = None,
-        extra_environ: Mapping[str, Any] | None = None,
-    ) -> None:
-        with open_spinner(message) as spinner:
-            call_subprocess(
-                cmd,
-                command_desc=message,
-                cwd=cwd,
-                extra_environ=extra_environ,
-                spinner=spinner,
-            )
-
-    return runner