@scrypted/server 0.0.141 → 0.0.145

package/.venv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py

@@ -1,155 +0,0 @@
-"""Utilities to lazily create and visit candidates found.
-
-Creating and visiting a candidate is a *very* costly operation. It involves
-fetching, extracting, potentially building modules from source, and verifying
-distribution metadata. It is therefore crucial for performance to keep
-everything here lazy all the way down, so we only touch candidates that we
-absolutely need, and not "download the world" when we only need one version of
-something.
-"""
-
-import functools
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, Set, Tuple
-
-from pip._vendor.packaging.version import _BaseVersion
-
-from .base import Candidate
-
-IndexCandidateInfo = Tuple[_BaseVersion, Callable[[], Optional[Candidate]]]
-
-if TYPE_CHECKING:
-    SequenceCandidate = Sequence[Candidate]
-else:
-    # For compatibility: Python before 3.9 does not support using [] on the
-    # Sequence class.
-    #
-    # >>> from collections.abc import Sequence
-    # >>> Sequence[str]
-    # Traceback (most recent call last):
-    #   File "<stdin>", line 1, in <module>
-    # TypeError: 'ABCMeta' object is not subscriptable
-    #
-    # TODO: Remove this block after dropping Python 3.8 support.
-    SequenceCandidate = Sequence
-
-
-def _iter_built(infos: Iterator[IndexCandidateInfo]) -> Iterator[Candidate]:
-    """Iterator for ``FoundCandidates``.
-
-    This iterator is used when the package is not already installed. Candidates
-    from index come later in their normal ordering.
-    """
-    versions_found: Set[_BaseVersion] = set()
-    for version, func in infos:
-        if version in versions_found:
-            continue
-        candidate = func()
-        if candidate is None:
-            continue
-        yield candidate
-        versions_found.add(version)
-
-
-def _iter_built_with_prepended(
-    installed: Candidate, infos: Iterator[IndexCandidateInfo]
-) -> Iterator[Candidate]:
-    """Iterator for ``FoundCandidates``.
-
-    This iterator is used when the resolver prefers the already-installed
-    candidate and NOT to upgrade. The installed candidate is therefore
-    always yielded first, and candidates from index come later in their
-    normal ordering, except skipped when the version is already installed.
-    """
-    yield installed
-    versions_found: Set[_BaseVersion] = {installed.version}
-    for version, func in infos:
-        if version in versions_found:
-            continue
-        candidate = func()
-        if candidate is None:
-            continue
-        yield candidate
-        versions_found.add(version)
-
-
-def _iter_built_with_inserted(
-    installed: Candidate, infos: Iterator[IndexCandidateInfo]
-) -> Iterator[Candidate]:
-    """Iterator for ``FoundCandidates``.
-
-    This iterator is used when the resolver prefers to upgrade an
-    already-installed package. Candidates from index are returned in their
-    normal ordering, except replaced when the version is already installed.
-
-    The implementation iterates through and yields other candidates, inserting
-    the installed candidate exactly once before we start yielding older or
-    equivalent candidates, or after all other candidates if they are all newer.
-    """
-    versions_found: Set[_BaseVersion] = set()
-    for version, func in infos:
-        if version in versions_found:
-            continue
-        # If the installed candidate is better, yield it first.
-        if installed.version >= version:
-            yield installed
-            versions_found.add(installed.version)
-        candidate = func()
-        if candidate is None:
-            continue
-        yield candidate
-        versions_found.add(version)
-
-    # If the installed candidate is older than all other candidates.
-    if installed.version not in versions_found:
-        yield installed
-
-
-class FoundCandidates(SequenceCandidate):
-    """A lazy sequence to provide candidates to the resolver.
-
-    The intended usage is to return this from `find_matches()` so the resolver
-    can iterate through the sequence multiple times, but only access the index
-    page when remote packages are actually needed. This improve performances
-    when suitable candidates are already installed on disk.
-    """
-
-    def __init__(
-        self,
-        get_infos: Callable[[], Iterator[IndexCandidateInfo]],
-        installed: Optional[Candidate],
-        prefers_installed: bool,
-        incompatible_ids: Set[int],
-    ):
-        self._get_infos = get_infos
-        self._installed = installed
-        self._prefers_installed = prefers_installed
-        self._incompatible_ids = incompatible_ids
-
-    def __getitem__(self, index: Any) -> Any:
-        # Implemented to satisfy the ABC check. This is not needed by the
-        # resolver, and should not be used by the provider either (for
-        # performance reasons).
-        raise NotImplementedError("don't do this")
-
-    def __iter__(self) -> Iterator[Candidate]:
-        infos = self._get_infos()
-        if not self._installed:
-            iterator = _iter_built(infos)
-        elif self._prefers_installed:
-            iterator = _iter_built_with_prepended(self._installed, infos)
-        else:
-            iterator = _iter_built_with_inserted(self._installed, infos)
-        return (c for c in iterator if id(c) not in self._incompatible_ids)
-
-    def __len__(self) -> int:
-        # Implemented to satisfy the ABC check. This is not needed by the
-        # resolver, and should not be used by the provider either (for
-        # performance reasons).
-        raise NotImplementedError("don't do this")
-
-    @functools.lru_cache(maxsize=1)
-    def __bool__(self) -> bool:
-        if self._prefers_installed and self._installed:
-            return True
-        return any(self)

package/.venv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/provider.py

@@ -1,215 +0,0 @@
-import collections
-import math
-from typing import TYPE_CHECKING, Dict, Iterable, Iterator, Mapping, Sequence, Union
-
-from pip._vendor.resolvelib.providers import AbstractProvider
-
-from .base import Candidate, Constraint, Requirement
-from .candidates import REQUIRES_PYTHON_IDENTIFIER
-from .factory import Factory
-
-if TYPE_CHECKING:
-    from pip._vendor.resolvelib.providers import Preference
-    from pip._vendor.resolvelib.resolvers import RequirementInformation
-
-    PreferenceInformation = RequirementInformation[Requirement, Candidate]
-
-    _ProviderBase = AbstractProvider[Requirement, Candidate, str]
-else:
-    _ProviderBase = AbstractProvider
-
-# Notes on the relationship between the provider, the factory, and the
-# candidate and requirement classes.
-#
-# The provider is a direct implementation of the resolvelib class. Its role
-# is to deliver the API that resolvelib expects.
-#
-# Rather than work with completely abstract "requirement" and "candidate"
-# concepts as resolvelib does, pip has concrete classes implementing these two
-# ideas. The API of Requirement and Candidate objects are defined in the base
-# classes, but essentially map fairly directly to the equivalent provider
-# methods. In particular, `find_matches` and `is_satisfied_by` are
-# requirement methods, and `get_dependencies` is a candidate method.
-#
-# The factory is the interface to pip's internal mechanisms. It is stateless,
-# and is created by the resolver and held as a property of the provider. It is
-# responsible for creating Requirement and Candidate objects, and provides
-# services to those objects (access to pip's finder and preparer).
-
-
-class PipProvider(_ProviderBase):
-    """Pip's provider implementation for resolvelib.
-
-    :params constraints: A mapping of constraints specified by the user. Keys
-        are canonicalized project names.
-    :params ignore_dependencies: Whether the user specified ``--no-deps``.
-    :params upgrade_strategy: The user-specified upgrade strategy.
-    :params user_requested: A set of canonicalized package names that the user
-        supplied for pip to install/upgrade.
-    """
-
-    def __init__(
-        self,
-        factory: Factory,
-        constraints: Dict[str, Constraint],
-        ignore_dependencies: bool,
-        upgrade_strategy: str,
-        user_requested: Dict[str, int],
-    ) -> None:
-        self._factory = factory
-        self._constraints = constraints
-        self._ignore_dependencies = ignore_dependencies
-        self._upgrade_strategy = upgrade_strategy
-        self._user_requested = user_requested
-        self._known_depths: Dict[str, float] = collections.defaultdict(lambda: math.inf)
-
-    def identify(self, requirement_or_candidate: Union[Requirement, Candidate]) -> str:
-        return requirement_or_candidate.name
-
-    def get_preference(  # type: ignore
-        self,
-        identifier: str,
-        resolutions: Mapping[str, Candidate],
-        candidates: Mapping[str, Iterator[Candidate]],
-        information: Mapping[str, Iterable["PreferenceInformation"]],
-        backtrack_causes: Sequence["PreferenceInformation"],
-    ) -> "Preference":
-        """Produce a sort key for given requirement based on preference.
-
-        The lower the return value is, the more preferred this group of
-        arguments is.
-
-        Currently pip considers the followings in order:
-
-        * Prefer if any of the known requirements is "direct", e.g. points to an
-          explicit URL.
-        * If equal, prefer if any requirement is "pinned", i.e. contains
-          operator ``===`` or ``==``.
-        * If equal, calculate an approximate "depth" and resolve requirements
-          closer to the user-specified requirements first.
-        * Order user-specified requirements by the order they are specified.
-        * If equal, prefers "non-free" requirements, i.e. contains at least one
-          operator, such as ``>=`` or ``<``.
-        * If equal, order alphabetically for consistency (helps debuggability).
-        """
-        lookups = (r.get_candidate_lookup() for r, _ in information[identifier])
-        candidate, ireqs = zip(*lookups)
-        operators = [
-            specifier.operator
-            for specifier_set in (ireq.specifier for ireq in ireqs if ireq)
-            for specifier in specifier_set
-        ]
-
-        direct = candidate is not None
-        pinned = any(op[:2] == "==" for op in operators)
-        unfree = bool(operators)
-
-        try:
-            requested_order: Union[int, float] = self._user_requested[identifier]
-        except KeyError:
-            requested_order = math.inf
-            parent_depths = (
-                self._known_depths[parent.name] if parent is not None else 0.0
-                for _, parent in information[identifier]
-            )
-            inferred_depth = min(d for d in parent_depths) + 1.0
-        else:
-            inferred_depth = 1.0
-        self._known_depths[identifier] = inferred_depth
-
-        requested_order = self._user_requested.get(identifier, math.inf)
-
-        # Requires-Python has only one candidate and the check is basically
-        # free, so we always do it first to avoid needless work if it fails.
-        requires_python = identifier == REQUIRES_PYTHON_IDENTIFIER
-
-        # HACK: Setuptools have a very long and solid backward compatibility
-        # track record, and extremely few projects would request a narrow,
-        # non-recent version range of it since that would break a lot things.
-        # (Most projects specify it only to request for an installer feature,
-        # which does not work, but that's another topic.) Intentionally
-        # delaying Setuptools helps reduce branches the resolver has to check.
-        # This serves as a temporary fix for issues like "apache-airlfow[all]"
-        # while we work on "proper" branch pruning techniques.
-        delay_this = identifier == "setuptools"
-
-        # Prefer the causes of backtracking on the assumption that the problem
-        # resolving the dependency tree is related to the failures that caused
-        # the backtracking
-        backtrack_cause = self.is_backtrack_cause(identifier, backtrack_causes)
-
-        return (
-            not requires_python,
-            delay_this,
-            not direct,
-            not pinned,
-            not backtrack_cause,
-            inferred_depth,
-            requested_order,
-            not unfree,
-            identifier,
-        )
-
-    def _get_constraint(self, identifier: str) -> Constraint:
-        if identifier in self._constraints:
-            return self._constraints[identifier]
-
-        # HACK: Theoratically we should check whether this identifier is a valid
-        # "NAME[EXTRAS]" format, and parse out the name part with packaging or
-        # some regular expression. But since pip's resolver only spits out
-        # three kinds of identifiers: normalized PEP 503 names, normalized names
-        # plus extras, and Requires-Python, we can cheat a bit here.
-        name, open_bracket, _ = identifier.partition("[")
-        if open_bracket and name in self._constraints:
-            return self._constraints[name]
-
-        return Constraint.empty()
-
-    def find_matches(
-        self,
-        identifier: str,
-        requirements: Mapping[str, Iterator[Requirement]],
-        incompatibilities: Mapping[str, Iterator[Candidate]],
-    ) -> Iterable[Candidate]:
-        def _eligible_for_upgrade(name: str) -> bool:
-            """Are upgrades allowed for this project?
-
-            This checks the upgrade strategy, and whether the project was one
-            that the user specified in the command line, in order to decide
-            whether we should upgrade if there's a newer version available.
-
-            (Note that we don't need access to the `--upgrade` flag, because
-            an upgrade strategy of "to-satisfy-only" means that `--upgrade`
-            was not specified).
-            """
-            if self._upgrade_strategy == "eager":
-                return True
-            elif self._upgrade_strategy == "only-if-needed":
-                return name in self._user_requested
-            return False
-
-        return self._factory.find_candidates(
-            identifier=identifier,
-            requirements=requirements,
-            constraint=self._get_constraint(identifier),
-            prefers_installed=(not _eligible_for_upgrade(identifier)),
-            incompatibilities=incompatibilities,
-        )
-
-    def is_satisfied_by(self, requirement: Requirement, candidate: Candidate) -> bool:
-        return requirement.is_satisfied_by(candidate)
-
-    def get_dependencies(self, candidate: Candidate) -> Sequence[Requirement]:
-        with_requires = not self._ignore_dependencies
-        return [r for r in candidate.iter_dependencies(with_requires) if r is not None]
-
-    @staticmethod
-    def is_backtrack_cause(
-        identifier: str, backtrack_causes: Sequence["PreferenceInformation"]
-    ) -> bool:
-        for backtrack_cause in backtrack_causes:
-            if identifier == backtrack_cause.requirement.name:
-                return True
-            if backtrack_cause.parent and identifier == backtrack_cause.parent.name:
-                return True
-        return False

package/.venv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/reporter.py

@@ -1,68 +0,0 @@
-from collections import defaultdict
-from logging import getLogger
-from typing import Any, DefaultDict
-
-from pip._vendor.resolvelib.reporters import BaseReporter
-
-from .base import Candidate, Requirement
-
-logger = getLogger(__name__)
-
-
-class PipReporter(BaseReporter):
-    def __init__(self) -> None:
-        self.backtracks_by_package: DefaultDict[str, int] = defaultdict(int)
-
-        self._messages_at_backtrack = {
-            1: (
-                "pip is looking at multiple versions of {package_name} to "
-                "determine which version is compatible with other "
-                "requirements. This could take a while."
-            ),
-            8: (
-                "pip is looking at multiple versions of {package_name} to "
-                "determine which version is compatible with other "
-                "requirements. This could take a while."
-            ),
-            13: (
-                "This is taking longer than usual. You might need to provide "
-                "the dependency resolver with stricter constraints to reduce "
-                "runtime. See https://pip.pypa.io/warnings/backtracking for "
-                "guidance. If you want to abort this run, press Ctrl + C."
-            ),
-        }
-
-    def backtracking(self, candidate: Candidate) -> None:
-        self.backtracks_by_package[candidate.name] += 1
-
-        count = self.backtracks_by_package[candidate.name]
-        if count not in self._messages_at_backtrack:
-            return
-
-        message = self._messages_at_backtrack[count]
-        logger.info("INFO: %s", message.format(package_name=candidate.name))
-
-
-class PipDebuggingReporter(BaseReporter):
-    """A reporter that does an info log for every event it sees."""
-
-    def starting(self) -> None:
-        logger.info("Reporter.starting()")
-
-    def starting_round(self, index: int) -> None:
-        logger.info("Reporter.starting_round(%r)", index)
-
-    def ending_round(self, index: int, state: Any) -> None:
-        logger.info("Reporter.ending_round(%r, state)", index)
-
-    def ending(self, state: Any) -> None:
-        logger.info("Reporter.ending(%r)", state)
-
-    def adding_requirement(self, requirement: Requirement, parent: Candidate) -> None:
-        logger.info("Reporter.adding_requirement(%r, %r)", requirement, parent)
-
-    def backtracking(self, candidate: Candidate) -> None:
-        logger.info("Reporter.backtracking(%r)", candidate)
-
-    def pinning(self, candidate: Candidate) -> None:
-        logger.info("Reporter.pinning(%r)", candidate)

package/.venv/lib/python3.9/site-packages/pip/_internal/resolution/resolvelib/requirements.py

@@ -1,166 +0,0 @@
-from pip._vendor.packaging.specifiers import SpecifierSet
-from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
-
-from pip._internal.req.req_install import InstallRequirement
-
-from .base import Candidate, CandidateLookup, Requirement, format_name
-
-
-class ExplicitRequirement(Requirement):
-    def __init__(self, candidate: Candidate) -> None:
-        self.candidate = candidate
-
-    def __str__(self) -> str:
-        return str(self.candidate)
-
-    def __repr__(self) -> str:
-        return "{class_name}({candidate!r})".format(
-            class_name=self.__class__.__name__,
-            candidate=self.candidate,
-        )
-
-    @property
-    def project_name(self) -> NormalizedName:
-        # No need to canonicalise - the candidate did this
-        return self.candidate.project_name
-
-    @property
-    def name(self) -> str:
-        # No need to canonicalise - the candidate did this
-        return self.candidate.name
-
-    def format_for_error(self) -> str:
-        return self.candidate.format_for_error()
-
-    def get_candidate_lookup(self) -> CandidateLookup:
-        return self.candidate, None
-
-    def is_satisfied_by(self, candidate: Candidate) -> bool:
-        return candidate == self.candidate
-
-
-class SpecifierRequirement(Requirement):
-    def __init__(self, ireq: InstallRequirement) -> None:
-        assert ireq.link is None, "This is a link, not a specifier"
-        self._ireq = ireq
-        self._extras = frozenset(ireq.extras)
-
-    def __str__(self) -> str:
-        return str(self._ireq.req)
-
-    def __repr__(self) -> str:
-        return "{class_name}({requirement!r})".format(
-            class_name=self.__class__.__name__,
-            requirement=str(self._ireq.req),
-        )
-
-    @property
-    def project_name(self) -> NormalizedName:
-        assert self._ireq.req, "Specifier-backed ireq is always PEP 508"
-        return canonicalize_name(self._ireq.req.name)
-
-    @property
-    def name(self) -> str:
-        return format_name(self.project_name, self._extras)
-
-    def format_for_error(self) -> str:
-
-        # Convert comma-separated specifiers into "A, B, ..., F and G"
-        # This makes the specifier a bit more "human readable", without
-        # risking a change in meaning. (Hopefully! Not all edge cases have
-        # been checked)
-        parts = [s.strip() for s in str(self).split(",")]
-        if len(parts) == 0:
-            return ""
-        elif len(parts) == 1:
-            return parts[0]
-
-        return ", ".join(parts[:-1]) + " and " + parts[-1]
-
-    def get_candidate_lookup(self) -> CandidateLookup:
-        return None, self._ireq
-
-    def is_satisfied_by(self, candidate: Candidate) -> bool:
-        assert candidate.name == self.name, (
-            f"Internal issue: Candidate is not for this requirement "
-            f"{candidate.name} vs {self.name}"
-        )
-        # We can safely always allow prereleases here since PackageFinder
-        # already implements the prerelease logic, and would have filtered out
-        # prerelease candidates if the user does not expect them.
-        assert self._ireq.req, "Specifier-backed ireq is always PEP 508"
-        spec = self._ireq.req.specifier
-        return spec.contains(candidate.version, prereleases=True)
-
-
-class RequiresPythonRequirement(Requirement):
-    """A requirement representing Requires-Python metadata."""
-
-    def __init__(self, specifier: SpecifierSet, match: Candidate) -> None:
-        self.specifier = specifier
-        self._candidate = match
-
-    def __str__(self) -> str:
-        return f"Python {self.specifier}"
-
-    def __repr__(self) -> str:
-        return "{class_name}({specifier!r})".format(
-            class_name=self.__class__.__name__,
-            specifier=str(self.specifier),
-        )
-
-    @property
-    def project_name(self) -> NormalizedName:
-        return self._candidate.project_name
-
-    @property
-    def name(self) -> str:
-        return self._candidate.name
-
-    def format_for_error(self) -> str:
-        return str(self)
-
-    def get_candidate_lookup(self) -> CandidateLookup:
-        if self.specifier.contains(self._candidate.version, prereleases=True):
-            return self._candidate, None
-        return None, None
-
-    def is_satisfied_by(self, candidate: Candidate) -> bool:
-        assert candidate.name == self._candidate.name, "Not Python candidate"
-        # We can safely always allow prereleases here since PackageFinder
-        # already implements the prerelease logic, and would have filtered out
-        # prerelease candidates if the user does not expect them.
-        return self.specifier.contains(candidate.version, prereleases=True)
-
-
-class UnsatisfiableRequirement(Requirement):
-    """A requirement that cannot be satisfied."""
-
-    def __init__(self, name: NormalizedName) -> None:
-        self._name = name
-
-    def __str__(self) -> str:
-        return f"{self._name} (unavailable)"
-
-    def __repr__(self) -> str:
-        return "{class_name}({name!r})".format(
-            class_name=self.__class__.__name__,
-            name=str(self._name),
-        )
-
-    @property
-    def project_name(self) -> NormalizedName:
-        return self._name
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    def format_for_error(self) -> str:
-        return str(self)
-
-    def get_candidate_lookup(self) -> CandidateLookup:
-        return None, None
-
-    def is_satisfied_by(self, candidate: Candidate) -> bool:
-        return False