@scrypted/server 0.0.139 → 0.0.143

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

@@ -1,254 +0,0 @@
-import collections
-import logging
-import os
-from typing import Container, Dict, Iterable, Iterator, List, NamedTuple, Optional, Set
-
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.packaging.version import Version
-
-from pip._internal.exceptions import BadCommand, InstallationError
-from pip._internal.metadata import BaseDistribution, get_environment
-from pip._internal.req.constructors import (
-    install_req_from_editable,
-    install_req_from_line,
-)
-from pip._internal.req.req_file import COMMENT_RE
-from pip._internal.utils.direct_url_helpers import direct_url_as_pep440_direct_reference
-
-logger = logging.getLogger(__name__)
-
-
-class _EditableInfo(NamedTuple):
-    requirement: str
-    comments: List[str]
-
-
-def freeze(
-    requirement: Optional[List[str]] = None,
-    local_only: bool = False,
-    user_only: bool = False,
-    paths: Optional[List[str]] = None,
-    isolated: bool = False,
-    exclude_editable: bool = False,
-    skip: Container[str] = (),
-) -> Iterator[str]:
-    installations: Dict[str, FrozenRequirement] = {}
-
-    dists = get_environment(paths).iter_installed_distributions(
-        local_only=local_only,
-        skip=(),
-        user_only=user_only,
-    )
-    for dist in dists:
-        req = FrozenRequirement.from_dist(dist)
-        if exclude_editable and req.editable:
-            continue
-        installations[req.canonical_name] = req
-
-    if requirement:
-        # the options that don't get turned into an InstallRequirement
-        # should only be emitted once, even if the same option is in multiple
-        # requirements files, so we need to keep track of what has been emitted
-        # so that we don't emit it again if it's seen again
-        emitted_options: Set[str] = set()
-        # keep track of which files a requirement is in so that we can
-        # give an accurate warning if a requirement appears multiple times.
-        req_files: Dict[str, List[str]] = collections.defaultdict(list)
-        for req_file_path in requirement:
-            with open(req_file_path) as req_file:
-                for line in req_file:
-                    if (
-                        not line.strip()
-                        or line.strip().startswith("#")
-                        or line.startswith(
-                            (
-                                "-r",
-                                "--requirement",
-                                "-f",
-                                "--find-links",
-                                "-i",
-                                "--index-url",
-                                "--pre",
-                                "--trusted-host",
-                                "--process-dependency-links",
-                                "--extra-index-url",
-                                "--use-feature",
-                            )
-                        )
-                    ):
-                        line = line.rstrip()
-                        if line not in emitted_options:
-                            emitted_options.add(line)
-                            yield line
-                        continue
-
-                    if line.startswith("-e") or line.startswith("--editable"):
-                        if line.startswith("-e"):
-                            line = line[2:].strip()
-                        else:
-                            line = line[len("--editable") :].strip().lstrip("=")
-                        line_req = install_req_from_editable(
-                            line,
-                            isolated=isolated,
-                        )
-                    else:
-                        line_req = install_req_from_line(
-                            COMMENT_RE.sub("", line).strip(),
-                            isolated=isolated,
-                        )
-
-                    if not line_req.name:
-                        logger.info(
-                            "Skipping line in requirement file [%s] because "
-                            "it's not clear what it would install: %s",
-                            req_file_path,
-                            line.strip(),
-                        )
-                        logger.info(
-                            "  (add #egg=PackageName to the URL to avoid"
-                            " this warning)"
-                        )
-                    else:
-                        line_req_canonical_name = canonicalize_name(line_req.name)
-                        if line_req_canonical_name not in installations:
-                            # either it's not installed, or it is installed
-                            # but has been processed already
-                            if not req_files[line_req.name]:
-                                logger.warning(
-                                    "Requirement file [%s] contains %s, but "
-                                    "package %r is not installed",
-                                    req_file_path,
-                                    COMMENT_RE.sub("", line).strip(),
-                                    line_req.name,
-                                )
-                            else:
-                                req_files[line_req.name].append(req_file_path)
-                        else:
-                            yield str(installations[line_req_canonical_name]).rstrip()
-                            del installations[line_req_canonical_name]
-                            req_files[line_req.name].append(req_file_path)
-
-        # Warn about requirements that were included multiple times (in a
-        # single requirements file or in different requirements files).
-        for name, files in req_files.items():
-            if len(files) > 1:
-                logger.warning(
-                    "Requirement %s included multiple times [%s]",
-                    name,
-                    ", ".join(sorted(set(files))),
-                )
-
-        yield ("## The following requirements were added by pip freeze:")
-    for installation in sorted(installations.values(), key=lambda x: x.name.lower()):
-        if installation.canonical_name not in skip:
-            yield str(installation).rstrip()
-
-
-def _format_as_name_version(dist: BaseDistribution) -> str:
-    if isinstance(dist.version, Version):
-        return f"{dist.raw_name}=={dist.version}"
-    return f"{dist.raw_name}==={dist.version}"
-
-
-def _get_editable_info(dist: BaseDistribution) -> _EditableInfo:
-    """
-    Compute and return values (req, comments) for use in
-    FrozenRequirement.from_dist().
-    """
-    editable_project_location = dist.editable_project_location
-    assert editable_project_location
-    location = os.path.normcase(os.path.abspath(editable_project_location))
-
-    from pip._internal.vcs import RemoteNotFoundError, RemoteNotValidError, vcs
-
-    vcs_backend = vcs.get_backend_for_dir(location)
-
-    if vcs_backend is None:
-        display = _format_as_name_version(dist)
-        logger.debug(
-            'No VCS found for editable requirement "%s" in: %r',
-            display,
-            location,
-        )
-        return _EditableInfo(
-            requirement=location,
-            comments=[f"# Editable install with no version control ({display})"],
-        )
-
-    vcs_name = type(vcs_backend).__name__
-
-    try:
-        req = vcs_backend.get_src_requirement(location, dist.raw_name)
-    except RemoteNotFoundError:
-        display = _format_as_name_version(dist)
-        return _EditableInfo(
-            requirement=location,
-            comments=[f"# Editable {vcs_name} install with no remote ({display})"],
-        )
-    except RemoteNotValidError as ex:
-        display = _format_as_name_version(dist)
-        return _EditableInfo(
-            requirement=location,
-            comments=[
-                f"# Editable {vcs_name} install ({display}) with either a deleted "
-                f"local remote or invalid URI:",
-                f"# '{ex.url}'",
-            ],
-        )
-    except BadCommand:
-        logger.warning(
-            "cannot determine version of editable source in %s "
-            "(%s command not found in path)",
-            location,
-            vcs_backend.name,
-        )
-        return _EditableInfo(requirement=location, comments=[])
-    except InstallationError as exc:
-        logger.warning("Error when trying to get requirement for VCS system %s", exc)
-    else:
-        return _EditableInfo(requirement=req, comments=[])
-
-    logger.warning("Could not determine repository location of %s", location)
-
-    return _EditableInfo(
-        requirement=location,
-        comments=["## !! Could not determine repository location"],
-    )
-
-
-class FrozenRequirement:
-    def __init__(
-        self,
-        name: str,
-        req: str,
-        editable: bool,
-        comments: Iterable[str] = (),
-    ) -> None:
-        self.name = name
-        self.canonical_name = canonicalize_name(name)
-        self.req = req
-        self.editable = editable
-        self.comments = comments
-
-    @classmethod
-    def from_dist(cls, dist: BaseDistribution) -> "FrozenRequirement":
-        editable = dist.editable
-        if editable:
-            req, comments = _get_editable_info(dist)
-        else:
-            comments = []
-            direct_url = dist.direct_url
-            if direct_url:
-                # if PEP 610 metadata is present, use it
-                req = direct_url_as_pep440_direct_reference(direct_url, dist.raw_name)
-            else:
-                # name==version requirement
-                req = _format_as_name_version(dist)
-
-        return cls(dist.raw_name, req, editable, comments=comments)
-
-    def __str__(self) -> str:
-        req = self.req
-        if self.editable:
-            req = f"-e {req}"
-        return "\n".join(list(self.comments) + [str(req)]) + "\n"

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

@@ -1,2 +0,0 @@
-"""For modules related to installing packages.
-"""

package/.venv/lib/python3.9/site-packages/pip/_internal/operations/install/editable_legacy.py

@@ -1,46 +0,0 @@
-"""Legacy editable installation process, i.e. `setup.py develop`.
-"""
-import logging
-from typing import List, Optional, Sequence
-
-from pip._internal.build_env import BuildEnvironment
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.setuptools_build import make_setuptools_develop_args
-from pip._internal.utils.subprocess import call_subprocess
-
-logger = logging.getLogger(__name__)
-
-
-def install_editable(
-    install_options: List[str],
-    global_options: Sequence[str],
-    prefix: Optional[str],
-    home: Optional[str],
-    use_user_site: bool,
-    name: str,
-    setup_py_path: str,
-    isolated: bool,
-    build_env: BuildEnvironment,
-    unpacked_source_directory: str,
-) -> None:
-    """Install a package in editable mode. Most arguments are pass-through
-    to setuptools.
-    """
-    logger.info("Running setup.py develop for %s", name)
-
-    args = make_setuptools_develop_args(
-        setup_py_path,
-        global_options=global_options,
-        install_options=install_options,
-        no_user_config=isolated,
-        prefix=prefix,
-        home=home,
-        use_user_site=use_user_site,
-    )
-
-    with indent_log():
-        with build_env:
-            call_subprocess(
-                args,
-                cwd=unpacked_source_directory,
-            )

package/.venv/lib/python3.9/site-packages/pip/_internal/operations/install/legacy.py

@@ -1,125 +0,0 @@
-"""Legacy installation process, i.e. `setup.py install`.
-"""
-
-import logging
-import os
-from distutils.util import change_root
-from typing import List, Optional, Sequence
-
-from pip._internal.build_env import BuildEnvironment
-from pip._internal.exceptions import InstallationError
-from pip._internal.models.scheme import Scheme
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import ensure_dir
-from pip._internal.utils.setuptools_build import make_setuptools_install_args
-from pip._internal.utils.subprocess import runner_with_spinner_message
-from pip._internal.utils.temp_dir import TempDirectory
-
-logger = logging.getLogger(__name__)
-
-
-class LegacyInstallFailure(Exception):
-    pass
-
-
-def write_installed_files_from_setuptools_record(
-    record_lines: List[str],
-    root: Optional[str],
-    req_description: str,
-) -> None:
-    def prepend_root(path: str) -> str:
-        if root is None or not os.path.isabs(path):
-            return path
-        else:
-            return change_root(root, path)
-
-    for line in record_lines:
-        directory = os.path.dirname(line)
-        if directory.endswith(".egg-info"):
-            egg_info_dir = prepend_root(directory)
-            break
-    else:
-        message = (
-            "{} did not indicate that it installed an "
-            ".egg-info directory. Only setup.py projects "
-            "generating .egg-info directories are supported."
-        ).format(req_description)
-        raise InstallationError(message)
-
-    new_lines = []
-    for line in record_lines:
-        filename = line.strip()
-        if os.path.isdir(filename):
-            filename += os.path.sep
-        new_lines.append(os.path.relpath(prepend_root(filename), egg_info_dir))
-    new_lines.sort()
-    ensure_dir(egg_info_dir)
-    inst_files_path = os.path.join(egg_info_dir, "installed-files.txt")
-    with open(inst_files_path, "w") as f:
-        f.write("\n".join(new_lines) + "\n")
-
-
-def install(
-    install_options: List[str],
-    global_options: Sequence[str],
-    root: Optional[str],
-    home: Optional[str],
-    prefix: Optional[str],
-    use_user_site: bool,
-    pycompile: bool,
-    scheme: Scheme,
-    setup_py_path: str,
-    isolated: bool,
-    req_name: str,
-    build_env: BuildEnvironment,
-    unpacked_source_directory: str,
-    req_description: str,
-) -> bool:
-
-    header_dir = scheme.headers
-
-    with TempDirectory(kind="record") as temp_dir:
-        try:
-            record_filename = os.path.join(temp_dir.path, "install-record.txt")
-            install_args = make_setuptools_install_args(
-                setup_py_path,
-                global_options=global_options,
-                install_options=install_options,
-                record_filename=record_filename,
-                root=root,
-                prefix=prefix,
-                header_dir=header_dir,
-                home=home,
-                use_user_site=use_user_site,
-                no_user_config=isolated,
-                pycompile=pycompile,
-            )
-
-            runner = runner_with_spinner_message(
-                f"Running setup.py install for {req_name}"
-            )
-            with indent_log(), build_env:
-                runner(
-                    cmd=install_args,
-                    cwd=unpacked_source_directory,
-                )
-
-            if not os.path.exists(record_filename):
-                logger.debug("Record file %s not found", record_filename)
-                # Signal to the caller that we didn't install the new package
-                return False
-
-        except Exception as e:
-            # Signal to the caller that we didn't install the new package
-            raise LegacyInstallFailure from e
-
-        # At this point, we have successfully installed the requirement.
-
-        # We intentionally do not use any encoding to read the file because
-        # setuptools writes the file using distutils.file_util.write_file,
-        # which does not specify an encoding.
-        with open(record_filename) as f:
-            record_lines = f.read().splitlines()
-
-    write_installed_files_from_setuptools_record(record_lines, root, req_description)
-    return True