cli-ih 0.6.3.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

venv/Lib/site-packages/pip/_vendor/resolvelib/__init__.py

@@ -1,27 +0,0 @@
-__all__ = [
-    "AbstractProvider",
-    "AbstractResolver",
-    "BaseReporter",
-    "InconsistentCandidate",
-    "RequirementsConflicted",
-    "ResolutionError",
-    "ResolutionImpossible",
-    "ResolutionTooDeep",
-    "Resolver",
-    "__version__",
-]
-
-__version__ = "1.2.0"
-
-
-from .providers import AbstractProvider
-from .reporters import BaseReporter
-from .resolvers import (
-    AbstractResolver,
-    InconsistentCandidate,
-    RequirementsConflicted,
-    ResolutionError,
-    ResolutionImpossible,
-    ResolutionTooDeep,
-    Resolver,
-)

venv/Lib/site-packages/pip/_vendor/resolvelib/providers.py

@@ -1,196 +0,0 @@
-from __future__ import annotations
-
-from typing import (
-    TYPE_CHECKING,
-    Generic,
-    Iterable,
-    Iterator,
-    Mapping,
-    Sequence,
-)
-
-from .structs import CT, KT, RT, Matches, RequirementInformation
-
-if TYPE_CHECKING:
-    from typing import Any, Protocol
-
-    class Preference(Protocol):
-        def __lt__(self, __other: Any) -> bool: ...
-
-
-class AbstractProvider(Generic[RT, CT, KT]):
-    """Delegate class to provide the required interface for the resolver."""
-
-    def identify(self, requirement_or_candidate: RT | CT) -> KT:
-        """Given a requirement or candidate, return an identifier for it.
-
-        This is used to identify, e.g. whether two requirements
-        should have their specifier parts merged or a candidate matches a
-        requirement via ``find_matches()``.
-        """
-        raise NotImplementedError
-
-    def get_preference(
-        self,
-        identifier: KT,
-        resolutions: Mapping[KT, CT],
-        candidates: Mapping[KT, Iterator[CT]],
-        information: Mapping[KT, Iterator[RequirementInformation[RT, CT]]],
-        backtrack_causes: Sequence[RequirementInformation[RT, CT]],
-    ) -> Preference:
-        """Produce a sort key for given requirement based on preference.
-
-        As this is a sort key it will be called O(n) times per backtrack
-        step, where n is the number of `identifier`s, if you have a check
-        which is expensive in some sense. E.g. It needs to make O(n) checks
-        per call or takes significant wall clock time, consider using
-        `narrow_requirement_selection` to filter the `identifier`s, which
-        is applied before this sort key is called.
-
-        The preference is defined as "I think this requirement should be
-        resolved first". The lower the return value is, the more preferred
-        this group of arguments is.
-
-        :param identifier: An identifier as returned by ``identify()``. This
-            identifies the requirement being considered.
-        :param resolutions: Mapping of candidates currently pinned by the
-            resolver. Each key is an identifier, and the value is a candidate.
-            The candidate may conflict with requirements from ``information``.
-        :param candidates: Mapping of each dependency's possible candidates.
-            Each value is an iterator of candidates.
-        :param information: Mapping of requirement information of each package.
-            Each value is an iterator of *requirement information*.
-        :param backtrack_causes: Sequence of *requirement information* that are
-            the requirements that caused the resolver to most recently
-            backtrack.
-
-        A *requirement information* instance is a named tuple with two members:
-
-        * ``requirement`` specifies a requirement contributing to the current
-          list of candidates.
-        * ``parent`` specifies the candidate that provides (depended on) the
-          requirement, or ``None`` to indicate a root requirement.
-
-        The preference could depend on various issues, including (not
-        necessarily in this order):
-
-        * Is this package pinned in the current resolution result?
-        * How relaxed is the requirement? Stricter ones should probably be
-          worked on first? (I don't know, actually.)
-        * How many possibilities are there to satisfy this requirement? Those
-          with few left should likely be worked on first, I guess?
-        * Are there any known conflicts for this requirement? We should
-          probably work on those with the most known conflicts.
-
-        A sortable value should be returned (this will be used as the ``key``
-        parameter of the built-in sorting function). The smaller the value is,
-        the more preferred this requirement is (i.e. the sorting function
-        is called with ``reverse=False``).
-        """
-        raise NotImplementedError
-
-    def find_matches(
-        self,
-        identifier: KT,
-        requirements: Mapping[KT, Iterator[RT]],
-        incompatibilities: Mapping[KT, Iterator[CT]],
-    ) -> Matches[CT]:
-        """Find all possible candidates that satisfy the given constraints.
-
-        :param identifier: An identifier as returned by ``identify()``. All
-            candidates returned by this method should produce the same
-            identifier.
-        :param requirements: A mapping of requirements that all returned
-            candidates must satisfy. Each key is an identifier, and the value
-            an iterator of requirements for that dependency.
-        :param incompatibilities: A mapping of known incompatibile candidates of
-            each dependency. Each key is an identifier, and the value an
-            iterator of incompatibilities known to the resolver. All
-            incompatibilities *must* be excluded from the return value.
-
-        This should try to get candidates based on the requirements' types.
-        For VCS, local, and archive requirements, the one-and-only match is
-        returned, and for a "named" requirement, the index(es) should be
-        consulted to find concrete candidates for this requirement.
-
-        The return value should produce candidates ordered by preference; the
-        most preferred candidate should come first. The return type may be one
-        of the following:
-
-        * A callable that returns an iterator that yields candidates.
-        * An collection of candidates.
-        * An iterable of candidates. This will be consumed immediately into a
-          list of candidates.
-        """
-        raise NotImplementedError
-
-    def is_satisfied_by(self, requirement: RT, candidate: CT) -> bool:
-        """Whether the given requirement can be satisfied by a candidate.
-
-        The candidate is guaranteed to have been generated from the
-        requirement.
-
-        A boolean should be returned to indicate whether ``candidate`` is a
-        viable solution to the requirement.
-        """
-        raise NotImplementedError
-
-    def get_dependencies(self, candidate: CT) -> Iterable[RT]:
-        """Get dependencies of a candidate.
-
-        This should return a collection of requirements that `candidate`
-        specifies as its dependencies.
-        """
-        raise NotImplementedError
-
-    def narrow_requirement_selection(
-        self,
-        identifiers: Iterable[KT],
-        resolutions: Mapping[KT, CT],
-        candidates: Mapping[KT, Iterator[CT]],
-        information: Mapping[KT, Iterator[RequirementInformation[RT, CT]]],
-        backtrack_causes: Sequence[RequirementInformation[RT, CT]],
-    ) -> Iterable[KT]:
-        """
-        An optional method to narrow the selection of requirements being
-        considered during resolution. This method is called O(1) time per
-        backtrack step.
-
-        :param identifiers: An iterable of `identifiers` as returned by
-            ``identify()``. These identify all requirements currently being
-            considered.
-        :param resolutions: A mapping of candidates currently pinned by the
-            resolver. Each key is an identifier, and the value is a candidate
-            that may conflict with requirements from ``information``.
-        :param candidates: A mapping of each dependency's possible candidates.
-            Each value is an iterator of candidates.
-        :param information: A mapping of requirement information for each package.
-            Each value is an iterator of *requirement information*.
-        :param backtrack_causes: A sequence of *requirement information* that are
-            the requirements causing the resolver to most recently
-            backtrack.
-
-        A *requirement information* instance is a named tuple with two members:
-
-        * ``requirement`` specifies a requirement contributing to the current
-          list of candidates.
-        * ``parent`` specifies the candidate that provides (is depended on for)
-          the requirement, or ``None`` to indicate a root requirement.
-
-        Must return a non-empty subset of `identifiers`, with the default
-        implementation being to return `identifiers` unchanged. Those `identifiers`
-        will then be passed to the sort key `get_preference` to pick the most
-        prefered requirement to attempt to pin, unless `narrow_requirement_selection`
-        returns only 1 requirement, in which case that will be used without
-        calling the sort key `get_preference`.
-
-        This method is designed to be used by the provider to optimize the
-        dependency resolution, e.g. if a check cost is O(m) and it can be done
-        against all identifiers at once then filtering the requirement selection
-        here will cost O(m) but making it part of the sort key in `get_preference`
-        will cost O(m*n), where n is the number of `identifiers`.
-
-        Returns:
-            Iterable[KT]: A non-empty subset of `identifiers`.
-        """
-        return identifiers

venv/Lib/site-packages/pip/_vendor/resolvelib/reporters.py

@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Collection, Generic
-
-from .structs import CT, KT, RT, RequirementInformation, State
-
-if TYPE_CHECKING:
-    from .resolvers import Criterion
-
-
-class BaseReporter(Generic[RT, CT, KT]):
-    """Delegate class to provide progress reporting for the resolver."""
-
-    def starting(self) -> None:
-        """Called before the resolution actually starts."""
-
-    def starting_round(self, index: int) -> None:
-        """Called before each round of resolution starts.
-
-        The index is zero-based.
-        """
-
-    def ending_round(self, index: int, state: State[RT, CT, KT]) -> None:
-        """Called before each round of resolution ends.
-
-        This is NOT called if the resolution ends at this round. Use `ending`
-        if you want to report finalization. The index is zero-based.
-        """
-
-    def ending(self, state: State[RT, CT, KT]) -> None:
-        """Called before the resolution ends successfully."""
-
-    def adding_requirement(self, requirement: RT, parent: CT | None) -> None:
-        """Called when adding a new requirement into the resolve criteria.
-
-        :param requirement: The additional requirement to be applied to filter
-            the available candidaites.
-        :param parent: The candidate that requires ``requirement`` as a
-            dependency, or None if ``requirement`` is one of the root
-            requirements passed in from ``Resolver.resolve()``.
-        """
-
-    def resolving_conflicts(
-        self, causes: Collection[RequirementInformation[RT, CT]]
-    ) -> None:
-        """Called when starting to attempt requirement conflict resolution.
-
-        :param causes: The information on the collision that caused the backtracking.
-        """
-
-    def rejecting_candidate(self, criterion: Criterion[RT, CT], candidate: CT) -> None:
-        """Called when rejecting a candidate during backtracking."""
-
-    def pinning(self, candidate: CT) -> None:
-        """Called when adding a candidate to the potential solution."""

venv/Lib/site-packages/pip/_vendor/resolvelib/resolvers/__init__.py

@@ -1,27 +0,0 @@
-from ..structs import RequirementInformation
-from .abstract import AbstractResolver, Result
-from .criterion import Criterion
-from .exceptions import (
-    InconsistentCandidate,
-    RequirementsConflicted,
-    ResolutionError,
-    ResolutionImpossible,
-    ResolutionTooDeep,
-    ResolverException,
-)
-from .resolution import Resolution, Resolver
-
-__all__ = [
-    "AbstractResolver",
-    "Criterion",
-    "InconsistentCandidate",
-    "RequirementInformation",
-    "RequirementsConflicted",
-    "Resolution",
-    "ResolutionError",
-    "ResolutionImpossible",
-    "ResolutionTooDeep",
-    "Resolver",
-    "ResolverException",
-    "Result",
-]

venv/Lib/site-packages/pip/_vendor/resolvelib/resolvers/abstract.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import collections
-from typing import TYPE_CHECKING, Any, Generic, Iterable, Mapping, NamedTuple
-
-from ..structs import CT, KT, RT, DirectedGraph
-
-if TYPE_CHECKING:
-    from ..providers import AbstractProvider
-    from ..reporters import BaseReporter
-    from .criterion import Criterion
-
-    class Result(NamedTuple, Generic[RT, CT, KT]):
-        mapping: Mapping[KT, CT]
-        graph: DirectedGraph[KT | None]
-        criteria: Mapping[KT, Criterion[RT, CT]]
-
-else:
-    Result = collections.namedtuple("Result", ["mapping", "graph", "criteria"])
-
-
-class AbstractResolver(Generic[RT, CT, KT]):
-    """The thing that performs the actual resolution work."""
-
-    base_exception = Exception
-
-    def __init__(
-        self,
-        provider: AbstractProvider[RT, CT, KT],
-        reporter: BaseReporter[RT, CT, KT],
-    ) -> None:
-        self.provider = provider
-        self.reporter = reporter
-
-    def resolve(self, requirements: Iterable[RT], **kwargs: Any) -> Result[RT, CT, KT]:
-        """Take a collection of constraints, spit out the resolution result.
-
-        This returns a representation of the final resolution state, with one
-        guarenteed attribute ``mapping`` that contains resolved candidates as
-        values. The keys are their respective identifiers.
-
-        :param requirements: A collection of constraints.
-        :param kwargs: Additional keyword arguments that subclasses may accept.
-
-        :raises: ``self.base_exception`` or its subclass.
-        """
-        raise NotImplementedError

venv/Lib/site-packages/pip/_vendor/resolvelib/resolvers/criterion.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from typing import Collection, Generic, Iterable, Iterator
-
-from ..structs import CT, RT, RequirementInformation
-
-
-class Criterion(Generic[RT, CT]):
-    """Representation of possible resolution results of a package.
-
-    This holds three attributes:
-
-    * `information` is a collection of `RequirementInformation` pairs.
-      Each pair is a requirement contributing to this criterion, and the
-      candidate that provides the requirement.
-    * `incompatibilities` is a collection of all known not-to-work candidates
-      to exclude from consideration.
-    * `candidates` is a collection containing all possible candidates deducted
-      from the union of contributing requirements and known incompatibilities.
-      It should never be empty, except when the criterion is an attribute of a
-      raised `RequirementsConflicted` (in which case it is always empty).
-
-    .. note::
-        This class is intended to be externally immutable. **Do not** mutate
-        any of its attribute containers.
-    """
-
-    def __init__(
-        self,
-        candidates: Iterable[CT],
-        information: Collection[RequirementInformation[RT, CT]],
-        incompatibilities: Collection[CT],
-    ) -> None:
-        self.candidates = candidates
-        self.information = information
-        self.incompatibilities = incompatibilities
-
-    def __repr__(self) -> str:
-        requirements = ", ".join(
-            f"({req!r}, via={parent!r})" for req, parent in self.information
-        )
-        return f"Criterion({requirements})"
-
-    def iter_requirement(self) -> Iterator[RT]:
-        return (i.requirement for i in self.information)
-
-    def iter_parent(self) -> Iterator[CT | None]:
-        return (i.parent for i in self.information)

venv/Lib/site-packages/pip/_vendor/resolvelib/resolvers/exceptions.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Collection, Generic
-
-from ..structs import CT, RT, RequirementInformation
-
-if TYPE_CHECKING:
-    from .criterion import Criterion
-
-
-class ResolverException(Exception):
-    """A base class for all exceptions raised by this module.
-
-    Exceptions derived by this class should all be handled in this module. Any
-    bubbling pass the resolver should be treated as a bug.
-    """
-
-
-class RequirementsConflicted(ResolverException, Generic[RT, CT]):
-    def __init__(self, criterion: Criterion[RT, CT]) -> None:
-        super().__init__(criterion)
-        self.criterion = criterion
-
-    def __str__(self) -> str:
-        return "Requirements conflict: {}".format(
-            ", ".join(repr(r) for r in self.criterion.iter_requirement()),
-        )
-
-
-class InconsistentCandidate(ResolverException, Generic[RT, CT]):
-    def __init__(self, candidate: CT, criterion: Criterion[RT, CT]):
-        super().__init__(candidate, criterion)
-        self.candidate = candidate
-        self.criterion = criterion
-
-    def __str__(self) -> str:
-        return "Provided candidate {!r} does not satisfy {}".format(
-            self.candidate,
-            ", ".join(repr(r) for r in self.criterion.iter_requirement()),
-        )
-
-
-class ResolutionError(ResolverException):
-    pass
-
-
-class ResolutionImpossible(ResolutionError, Generic[RT, CT]):
-    def __init__(self, causes: Collection[RequirementInformation[RT, CT]]):
-        super().__init__(causes)
-        # causes is a list of RequirementInformation objects
-        self.causes = causes
-
-
-class ResolutionTooDeep(ResolutionError):
-    def __init__(self, round_count: int) -> None:
-        super().__init__(round_count)
-        self.round_count = round_count