@scrypted/server 0.0.139 → 0.0.143

package/.venv/lib/python3.9/site-packages/pip/_internal/locations/_distutils.py

@@ -1,169 +0,0 @@
-"""Locations where we look for configs, install stuff, etc"""
-
-# The following comment should be removed at some point in the future.
-# mypy: strict-optional=False
-
-import logging
-import os
-import sys
-from distutils.cmd import Command as DistutilsCommand
-from distutils.command.install import SCHEME_KEYS
-from distutils.command.install import install as distutils_install_command
-from distutils.sysconfig import get_python_lib
-from typing import Dict, List, Optional, Tuple, Union, cast
-
-from pip._internal.models.scheme import Scheme
-from pip._internal.utils.compat import WINDOWS
-from pip._internal.utils.virtualenv import running_under_virtualenv
-
-from .base import get_major_minor_version
-
-logger = logging.getLogger(__name__)
-
-
-def distutils_scheme(
-    dist_name: str,
-    user: bool = False,
-    home: str = None,
-    root: str = None,
-    isolated: bool = False,
-    prefix: str = None,
-    *,
-    ignore_config_files: bool = False,
-) -> Dict[str, str]:
-    """
-    Return a distutils install scheme
-    """
-    from distutils.dist import Distribution
-
-    dist_args: Dict[str, Union[str, List[str]]] = {"name": dist_name}
-    if isolated:
-        dist_args["script_args"] = ["--no-user-cfg"]
-
-    d = Distribution(dist_args)
-    if not ignore_config_files:
-        try:
-            d.parse_config_files()
-        except UnicodeDecodeError:
-            # Typeshed does not include find_config_files() for some reason.
-            paths = d.find_config_files()  # type: ignore
-            logger.warning(
-                "Ignore distutils configs in %s due to encoding errors.",
-                ", ".join(os.path.basename(p) for p in paths),
-            )
-    obj: Optional[DistutilsCommand] = None
-    obj = d.get_command_obj("install", create=True)
-    assert obj is not None
-    i = cast(distutils_install_command, obj)
-    # NOTE: setting user or home has the side-effect of creating the home dir
-    # or user base for installations during finalize_options()
-    # ideally, we'd prefer a scheme class that has no side-effects.
-    assert not (user and prefix), f"user={user} prefix={prefix}"
-    assert not (home and prefix), f"home={home} prefix={prefix}"
-    i.user = user or i.user
-    if user or home:
-        i.prefix = ""
-    i.prefix = prefix or i.prefix
-    i.home = home or i.home
-    i.root = root or i.root
-    i.finalize_options()
-
-    scheme = {}
-    for key in SCHEME_KEYS:
-        scheme[key] = getattr(i, "install_" + key)
-
-    # install_lib specified in setup.cfg should install *everything*
-    # into there (i.e. it takes precedence over both purelib and
-    # platlib).  Note, i.install_lib is *always* set after
-    # finalize_options(); we only want to override here if the user
-    # has explicitly requested it hence going back to the config
-    if "install_lib" in d.get_option_dict("install"):
-        scheme.update(dict(purelib=i.install_lib, platlib=i.install_lib))
-
-    if running_under_virtualenv():
-        if home:
-            prefix = home
-        elif user:
-            prefix = i.install_userbase  # type: ignore
-        else:
-            prefix = i.prefix
-        scheme["headers"] = os.path.join(
-            prefix,
-            "include",
-            "site",
-            f"python{get_major_minor_version()}",
-            dist_name,
-        )
-
-        if root is not None:
-            path_no_drive = os.path.splitdrive(os.path.abspath(scheme["headers"]))[1]
-            scheme["headers"] = os.path.join(root, path_no_drive[1:])
-
-    return scheme
-
-
-def get_scheme(
-    dist_name: str,
-    user: bool = False,
-    home: Optional[str] = None,
-    root: Optional[str] = None,
-    isolated: bool = False,
-    prefix: Optional[str] = None,
-) -> Scheme:
-    """
-    Get the "scheme" corresponding to the input parameters. The distutils
-    documentation provides the context for the available schemes:
-    https://docs.python.org/3/install/index.html#alternate-installation
-
-    :param dist_name: the name of the package to retrieve the scheme for, used
-        in the headers scheme path
-    :param user: indicates to use the "user" scheme
-    :param home: indicates to use the "home" scheme and provides the base
-        directory for the same
-    :param root: root under which other directories are re-based
-    :param isolated: equivalent to --no-user-cfg, i.e. do not consider
-        ~/.pydistutils.cfg (posix) or ~/pydistutils.cfg (non-posix) for
-        scheme paths
-    :param prefix: indicates to use the "prefix" scheme and provides the
-        base directory for the same
-    """
-    scheme = distutils_scheme(dist_name, user, home, root, isolated, prefix)
-    return Scheme(
-        platlib=scheme["platlib"],
-        purelib=scheme["purelib"],
-        headers=scheme["headers"],
-        scripts=scheme["scripts"],
-        data=scheme["data"],
-    )
-
-
-def get_bin_prefix() -> str:
-    # XXX: In old virtualenv versions, sys.prefix can contain '..' components,
-    # so we need to call normpath to eliminate them.
-    prefix = os.path.normpath(sys.prefix)
-    if WINDOWS:
-        bin_py = os.path.join(prefix, "Scripts")
-        # buildout uses 'bin' on Windows too?
-        if not os.path.exists(bin_py):
-            bin_py = os.path.join(prefix, "bin")
-        return bin_py
-    # Forcing to use /usr/local/bin for standard macOS framework installs
-    # Also log to ~/Library/Logs/ for use with the Console.app log viewer
-    if sys.platform[:6] == "darwin" and prefix[:16] == "/System/Library/":
-        return "/usr/local/bin"
-    return os.path.join(prefix, "bin")
-
-
-def get_purelib() -> str:
-    return get_python_lib(plat_specific=False)
-
-
-def get_platlib() -> str:
-    return get_python_lib(plat_specific=True)
-
-
-def get_prefixed_libs(prefix: str) -> Tuple[str, str]:
-    return (
-        get_python_lib(plat_specific=False, prefix=prefix),
-        get_python_lib(plat_specific=True, prefix=prefix),
-    )

package/.venv/lib/python3.9/site-packages/pip/_internal/locations/_sysconfig.py

@@ -1,219 +0,0 @@
-import distutils.util  # FIXME: For change_root.
-import logging
-import os
-import sys
-import sysconfig
-import typing
-
-from pip._internal.exceptions import InvalidSchemeCombination, UserInstallationInvalid
-from pip._internal.models.scheme import SCHEME_KEYS, Scheme
-from pip._internal.utils.virtualenv import running_under_virtualenv
-
-from .base import get_major_minor_version, is_osx_framework
-
-logger = logging.getLogger(__name__)
-
-
-# Notes on _infer_* functions.
-# Unfortunately ``get_default_scheme()`` didn't exist before 3.10, so there's no
-# way to ask things like "what is the '_prefix' scheme on this platform". These
-# functions try to answer that with some heuristics while accounting for ad-hoc
-# platforms not covered by CPython's default sysconfig implementation. If the
-# ad-hoc implementation does not fully implement sysconfig, we'll fall back to
-# a POSIX scheme.
-
-_AVAILABLE_SCHEMES = set(sysconfig.get_scheme_names())
-
-_PREFERRED_SCHEME_API = getattr(sysconfig, "get_preferred_scheme", None)
-
-
-def _should_use_osx_framework_prefix() -> bool:
-    """Check for Apple's ``osx_framework_library`` scheme.
-
-    Python distributed by Apple's Command Line Tools has this special scheme
-    that's used when:
-
-    * This is a framework build.
-    * We are installing into the system prefix.
-
-    This does not account for ``pip install --prefix`` (also means we're not
-    installing to the system prefix), which should use ``posix_prefix``, but
-    logic here means ``_infer_prefix()`` outputs ``osx_framework_library``. But
-    since ``prefix`` is not available for ``sysconfig.get_default_scheme()``,
-    which is the stdlib replacement for ``_infer_prefix()``, presumably Apple
-    wouldn't be able to magically switch between ``osx_framework_library`` and
-    ``posix_prefix``. ``_infer_prefix()`` returning ``osx_framework_library``
-    means its behavior is consistent whether we use the stdlib implementation
-    or our own, and we deal with this special case in ``get_scheme()`` instead.
-    """
-    return (
-        "osx_framework_library" in _AVAILABLE_SCHEMES
-        and not running_under_virtualenv()
-        and is_osx_framework()
-    )
-
-
-def _infer_prefix() -> str:
-    """Try to find a prefix scheme for the current platform.
-
-    This tries:
-
-    * A special ``osx_framework_library`` for Python distributed by Apple's
-      Command Line Tools, when not running in a virtual environment.
-    * Implementation + OS, used by PyPy on Windows (``pypy_nt``).
-    * Implementation without OS, used by PyPy on POSIX (``pypy``).
-    * OS + "prefix", used by CPython on POSIX (``posix_prefix``).
-    * Just the OS name, used by CPython on Windows (``nt``).
-
-    If none of the above works, fall back to ``posix_prefix``.
-    """
-    if _PREFERRED_SCHEME_API:
-        return _PREFERRED_SCHEME_API("prefix")
-    if _should_use_osx_framework_prefix():
-        return "osx_framework_library"
-    implementation_suffixed = f"{sys.implementation.name}_{os.name}"
-    if implementation_suffixed in _AVAILABLE_SCHEMES:
-        return implementation_suffixed
-    if sys.implementation.name in _AVAILABLE_SCHEMES:
-        return sys.implementation.name
-    suffixed = f"{os.name}_prefix"
-    if suffixed in _AVAILABLE_SCHEMES:
-        return suffixed
-    if os.name in _AVAILABLE_SCHEMES:  # On Windows, prefx is just called "nt".
-        return os.name
-    return "posix_prefix"
-
-
-def _infer_user() -> str:
-    """Try to find a user scheme for the current platform."""
-    if _PREFERRED_SCHEME_API:
-        return _PREFERRED_SCHEME_API("user")
-    if is_osx_framework() and not running_under_virtualenv():
-        suffixed = "osx_framework_user"
-    else:
-        suffixed = f"{os.name}_user"
-    if suffixed in _AVAILABLE_SCHEMES:
-        return suffixed
-    if "posix_user" not in _AVAILABLE_SCHEMES:  # User scheme unavailable.
-        raise UserInstallationInvalid()
-    return "posix_user"
-
-
-def _infer_home() -> str:
-    """Try to find a home for the current platform."""
-    if _PREFERRED_SCHEME_API:
-        return _PREFERRED_SCHEME_API("home")
-    suffixed = f"{os.name}_home"
-    if suffixed in _AVAILABLE_SCHEMES:
-        return suffixed
-    return "posix_home"
-
-
-# Update these keys if the user sets a custom home.
-_HOME_KEYS = [
-    "installed_base",
-    "base",
-    "installed_platbase",
-    "platbase",
-    "prefix",
-    "exec_prefix",
-]
-if sysconfig.get_config_var("userbase") is not None:
-    _HOME_KEYS.append("userbase")
-
-
-def get_scheme(
-    dist_name: str,
-    user: bool = False,
-    home: typing.Optional[str] = None,
-    root: typing.Optional[str] = None,
-    isolated: bool = False,
-    prefix: typing.Optional[str] = None,
-) -> Scheme:
-    """
-    Get the "scheme" corresponding to the input parameters.
-
-    :param dist_name: the name of the package to retrieve the scheme for, used
-        in the headers scheme path
-    :param user: indicates to use the "user" scheme
-    :param home: indicates to use the "home" scheme
-    :param root: root under which other directories are re-based
-    :param isolated: ignored, but kept for distutils compatibility (where
-        this controls whether the user-site pydistutils.cfg is honored)
-    :param prefix: indicates to use the "prefix" scheme and provides the
-        base directory for the same
-    """
-    if user and prefix:
-        raise InvalidSchemeCombination("--user", "--prefix")
-    if home and prefix:
-        raise InvalidSchemeCombination("--home", "--prefix")
-
-    if home is not None:
-        scheme_name = _infer_home()
-    elif user:
-        scheme_name = _infer_user()
-    else:
-        scheme_name = _infer_prefix()
-
-    # Special case: When installing into a custom prefix, use posix_prefix
-    # instead of osx_framework_library. See _should_use_osx_framework_prefix()
-    # docstring for details.
-    if prefix is not None and scheme_name == "osx_framework_library":
-        scheme_name = "posix_prefix"
-
-    if home is not None:
-        variables = {k: home for k in _HOME_KEYS}
-    elif prefix is not None:
-        variables = {k: prefix for k in _HOME_KEYS}
-    else:
-        variables = {}
-
-    paths = sysconfig.get_paths(scheme=scheme_name, vars=variables)
-
-    # Logic here is very arbitrary, we're doing it for compatibility, don't ask.
-    # 1. Pip historically uses a special header path in virtual environments.
-    # 2. If the distribution name is not known, distutils uses 'UNKNOWN'. We
-    #    only do the same when not running in a virtual environment because
-    #    pip's historical header path logic (see point 1) did not do this.
-    if running_under_virtualenv():
-        if user:
-            base = variables.get("userbase", sys.prefix)
-        else:
-            base = variables.get("base", sys.prefix)
-        python_xy = f"python{get_major_minor_version()}"
-        paths["include"] = os.path.join(base, "include", "site", python_xy)
-    elif not dist_name:
-        dist_name = "UNKNOWN"
-
-    scheme = Scheme(
-        platlib=paths["platlib"],
-        purelib=paths["purelib"],
-        headers=os.path.join(paths["include"], dist_name),
-        scripts=paths["scripts"],
-        data=paths["data"],
-    )
-    if root is not None:
-        for key in SCHEME_KEYS:
-            value = distutils.util.change_root(root, getattr(scheme, key))
-            setattr(scheme, key, value)
-    return scheme
-
-
-def get_bin_prefix() -> str:
-    # Forcing to use /usr/local/bin for standard macOS framework installs.
-    if sys.platform[:6] == "darwin" and sys.prefix[:16] == "/System/Library/":
-        return "/usr/local/bin"
-    return sysconfig.get_paths()["scripts"]
-
-
-def get_purelib() -> str:
-    return sysconfig.get_paths()["purelib"]
-
-
-def get_platlib() -> str:
-    return sysconfig.get_paths()["platlib"]
-
-
-def get_prefixed_libs(prefix: str) -> typing.Tuple[str, str]:
-    paths = sysconfig.get_paths(vars={"base": prefix, "platbase": prefix})
-    return (paths["purelib"], paths["platlib"])

package/.venv/lib/python3.9/site-packages/pip/_internal/locations/base.py

@@ -1,52 +0,0 @@
-import functools
-import os
-import site
-import sys
-import sysconfig
-import typing
-
-from pip._internal.utils import appdirs
-from pip._internal.utils.virtualenv import running_under_virtualenv
-
-# Application Directories
-USER_CACHE_DIR = appdirs.user_cache_dir("pip")
-
-# FIXME doesn't account for venv linked to global site-packages
-site_packages: typing.Optional[str] = sysconfig.get_path("purelib")
-
-
-def get_major_minor_version() -> str:
-    """
-    Return the major-minor version of the current Python as a string, e.g.
-    "3.7" or "3.10".
-    """
-    return "{}.{}".format(*sys.version_info)
-
-
-def get_src_prefix() -> str:
-    if running_under_virtualenv():
-        src_prefix = os.path.join(sys.prefix, "src")
-    else:
-        # FIXME: keep src in cwd for now (it is not a temporary folder)
-        try:
-            src_prefix = os.path.join(os.getcwd(), "src")
-        except OSError:
-            # In case the current working directory has been renamed or deleted
-            sys.exit("The folder you are executing pip from can no longer be found.")
-
-    # under macOS + virtualenv sys.prefix is not properly resolved
-    # it is something like /path/to/python/bin/..
-    return os.path.abspath(src_prefix)
-
-
-try:
-    # Use getusersitepackages if this is present, as it ensures that the
-    # value is initialised properly.
-    user_site: typing.Optional[str] = site.getusersitepackages()
-except AttributeError:
-    user_site = site.USER_SITE
-
-
-@functools.lru_cache(maxsize=None)
-def is_osx_framework() -> bool:
-    return bool(sysconfig.get_config_var("PYTHONFRAMEWORK"))

package/.venv/lib/python3.9/site-packages/pip/_internal/main.py

@@ -1,12 +0,0 @@
-from typing import List, Optional
-
-
-def main(args: Optional[List[str]] = None) -> int:
-    """This is preserved for old console scripts that may still be referencing
-    it.
-
-    For additional details, see https://github.com/pypa/pip/issues/7498.
-    """
-    from pip._internal.utils.entrypoints import _wrapper
-
-    return _wrapper(args)

package/.venv/lib/python3.9/site-packages/pip/_internal/metadata/__init__.py

@@ -1,51 +0,0 @@
-from typing import List, Optional
-
-from .base import BaseDistribution, BaseEnvironment, FilesystemWheel, MemoryWheel, Wheel
-
-__all__ = [
-    "BaseDistribution",
-    "BaseEnvironment",
-    "FilesystemWheel",
-    "MemoryWheel",
-    "Wheel",
-    "get_default_environment",
-    "get_environment",
-    "get_wheel_distribution",
-]
-
-
-def get_default_environment() -> BaseEnvironment:
-    """Get the default representation for the current environment.
-
-    This returns an Environment instance from the chosen backend. The default
-    Environment instance should be built from ``sys.path`` and may use caching
-    to share instance state accorss calls.
-    """
-    from .pkg_resources import Environment
-
-    return Environment.default()
-
-
-def get_environment(paths: Optional[List[str]]) -> BaseEnvironment:
-    """Get a representation of the environment specified by ``paths``.
-
-    This returns an Environment instance from the chosen backend based on the
-    given import paths. The backend must build a fresh instance representing
-    the state of installed distributions when this function is called.
-    """
-    from .pkg_resources import Environment
-
-    return Environment.from_paths(paths)
-
-
-def get_wheel_distribution(wheel: Wheel, canonical_name: str) -> BaseDistribution:
-    """Get the representation of the specified wheel's distribution metadata.
-
-    This returns a Distribution instance from the chosen backend based on
-    the given wheel's ``.dist-info`` directory.
-
-    :param canonical_name: Normalized project name of the given wheel.
-    """
-    from .pkg_resources import Distribution
-
-    return Distribution.from_wheel(wheel, canonical_name)