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

venv/Lib/site-packages/pip/_internal/models/pylock.py

@@ -1,188 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import re
-from collections.abc import Iterable
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from pip._vendor import tomli_w
-
-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
-
-if TYPE_CHECKING:
-    from typing_extensions import Self
-
-PYLOCK_FILE_NAME_RE = re.compile(r"^pylock\.([^.]+)\.toml$")
-
-
-def is_valid_pylock_file_name(path: Path) -> bool:
-    return path.name == "pylock.toml" or bool(re.match(PYLOCK_FILE_NAME_RE, path.name))
-
-
-def _toml_dict_factory(data: list[tuple[str, Any]]) -> dict[str, Any]:
-    return {key.replace("_", "-"): value for key, value in data if value is not None}
-
-
-@dataclass
-class PackageVcs:
-    type: str
-    url: str | None
-    # (not supported) path: Optional[str]
-    requested_revision: str | None
-    commit_id: str
-    subdirectory: str | None
-
-
-@dataclass
-class PackageDirectory:
-    path: str
-    editable: bool | None
-    subdirectory: str | None
-
-
-@dataclass
-class PackageArchive:
-    url: str | None
-    # (not supported) path: Optional[str]
-    # (not supported) size: Optional[int]
-    # (not supported) upload_time: Optional[datetime]
-    hashes: dict[str, str]
-    subdirectory: str | None
-
-
-@dataclass
-class PackageSdist:
-    name: str
-    # (not supported) upload_time: Optional[datetime]
-    url: str | None
-    # (not supported) path: Optional[str]
-    # (not supported) size: Optional[int]
-    hashes: dict[str, str]
-
-
-@dataclass
-class PackageWheel:
-    name: str
-    # (not supported) upload_time: Optional[datetime]
-    url: str | None
-    # (not supported) path: Optional[str]
-    # (not supported) size: Optional[int]
-    hashes: dict[str, str]
-
-
-@dataclass
-class Package:
-    name: str
-    version: str | None = None
-    # (not supported) marker: Optional[str]
-    # (not supported) requires_python: Optional[str]
-    # (not supported) dependencies
-    vcs: PackageVcs | None = None
-    directory: PackageDirectory | None = None
-    archive: PackageArchive | None = None
-    # (not supported) index: Optional[str]
-    sdist: PackageSdist | None = None
-    wheels: list[PackageWheel] | None = None
-    # (not supported) attestation_identities: Optional[List[Dict[str, Any]]]
-    # (not supported) tool: Optional[Dict[str, Any]]
-
-    @classmethod
-    def from_install_requirement(cls, ireq: InstallRequirement, base_dir: Path) -> Self:
-        base_dir = base_dir.resolve()
-        dist = ireq.get_dist()
-        download_info = ireq.download_info
-        assert download_info
-        package = cls(name=dist.canonical_name)
-        if ireq.is_direct:
-            if isinstance(download_info.info, VcsInfo):
-                package.vcs = PackageVcs(
-                    type=download_info.info.vcs,
-                    url=download_info.url,
-                    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,
-                    hashes=download_info.info.hashes,
-                    subdirectory=download_info.subdirectory,
-                )
-            else:
-                # should never happen
-                raise NotImplementedError()
-        else:
-            package.version = str(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
-
-
-@dataclass
-class Pylock:
-    lock_version: str = "1.0"
-    # (not supported) environments: Optional[List[str]]
-    # (not supported) requires_python: Optional[str]
-    # (not supported) extras: List[str] = []
-    # (not supported) dependency_groups: List[str] = []
-    created_by: str = "pip"
-    packages: list[Package] = dataclasses.field(default_factory=list)
-    # (not supported) tool: Optional[Dict[str, Any]]
-
-    def as_toml(self) -> str:
-        return tomli_w.dumps(dataclasses.asdict(self, dict_factory=_toml_dict_factory))
-
-    @classmethod
-    def from_install_requirements(
-        cls, install_requirements: Iterable[InstallRequirement], base_dir: Path
-    ) -> Self:
-        return cls(
-            packages=sorted(
-                (
-                    Package.from_install_requirement(ireq, base_dir)
-                    for ireq in install_requirements
-                ),
-                key=lambda p: p.name,
-            )
-        )

venv/Lib/site-packages/pip/_internal/models/scheme.py

@@ -1,25 +0,0 @@
-"""
-For types associated with installation schemes.
-
-For a general overview of available schemes and their context, see
-https://docs.python.org/3/install/index.html#alternate-installation.
-"""
-
-from dataclasses import dataclass
-
-SCHEME_KEYS = ["platlib", "purelib", "headers", "scripts", "data"]
-
-
-@dataclass(frozen=True)
-class Scheme:
-    """A Scheme holds paths which are used as the base directories for
-    artifacts associated with a Python package.
-    """
-
-    __slots__ = SCHEME_KEYS
-
-    platlib: str
-    purelib: str
-    headers: str
-    scripts: str
-    data: str

venv/Lib/site-packages/pip/_internal/models/search_scope.py

@@ -1,126 +0,0 @@
-import itertools
-import logging
-import os
-import posixpath
-import urllib.parse
-from dataclasses import dataclass
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.models.index import PyPI
-from pip._internal.utils.compat import has_tls
-from pip._internal.utils.misc import normalize_path, redact_auth_from_url
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class SearchScope:
-    """
-    Encapsulates the locations that pip is configured to search.
-    """
-
-    __slots__ = ["find_links", "index_urls", "no_index"]
-
-    find_links: list[str]
-    index_urls: list[str]
-    no_index: bool
-
-    @classmethod
-    def create(
-        cls,
-        find_links: list[str],
-        index_urls: list[str],
-        no_index: bool,
-    ) -> "SearchScope":
-        """
-        Create a SearchScope object after normalizing the `find_links`.
-        """
-        # Build find_links. If an argument starts with ~, it may be
-        # a local file relative to a home directory. So try normalizing
-        # it and if it exists, use the normalized version.
-        # This is deliberately conservative - it might be fine just to
-        # blindly normalize anything starting with a ~...
-        built_find_links: list[str] = []
-        for link in find_links:
-            if link.startswith("~"):
-                new_link = normalize_path(link)
-                if os.path.exists(new_link):
-                    link = new_link
-            built_find_links.append(link)
-
-        # If we don't have TLS enabled, then WARN if anyplace we're looking
-        # relies on TLS.
-        if not has_tls():
-            for link in itertools.chain(index_urls, built_find_links):
-                parsed = urllib.parse.urlparse(link)
-                if parsed.scheme == "https":
-                    logger.warning(
-                        "pip is configured with locations that require "
-                        "TLS/SSL, however the ssl module in Python is not "
-                        "available."
-                    )
-                    break
-
-        return cls(
-            find_links=built_find_links,
-            index_urls=index_urls,
-            no_index=no_index,
-        )
-
-    def get_formatted_locations(self) -> str:
-        lines = []
-        redacted_index_urls = []
-        if self.index_urls and self.index_urls != [PyPI.simple_url]:
-            for url in self.index_urls:
-                redacted_index_url = redact_auth_from_url(url)
-
-                # Parse the URL
-                purl = urllib.parse.urlsplit(redacted_index_url)
-
-                # URL is generally invalid if scheme and netloc is missing
-                # there are issues with Python and URL parsing, so this test
-                # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
-                # always parse invalid URLs correctly - it should raise
-                # exceptions for malformed URLs
-                if not purl.scheme and not purl.netloc:
-                    logger.warning(
-                        'The index url "%s" seems invalid, please provide a scheme.',
-                        redacted_index_url,
-                    )
-
-                redacted_index_urls.append(redacted_index_url)
-
-            lines.append(
-                "Looking in indexes: {}".format(", ".join(redacted_index_urls))
-            )
-
-        if self.find_links:
-            lines.append(
-                "Looking in links: {}".format(
-                    ", ".join(redact_auth_from_url(url) for url in self.find_links)
-                )
-            )
-        return "\n".join(lines)
-
-    def get_index_urls_locations(self, project_name: str) -> list[str]:
-        """Returns the locations found via self.index_urls
-
-        Checks the url_name on the main (first in the list) index and
-        use this url_name to produce all locations
-        """
-
-        def mkurl_pypi_url(url: str) -> str:
-            loc = posixpath.join(
-                url, urllib.parse.quote(canonicalize_name(project_name))
-            )
-            # For maximum compatibility with easy_install, ensure the path
-            # ends in a trailing slash.  Although this isn't in the spec
-            # (and PyPI can handle it without the slash) some other index
-            # implementations might break if they relied on easy_install's
-            # behavior.
-            if not loc.endswith("/"):
-                loc = loc + "/"
-            return loc
-
-        return [mkurl_pypi_url(url) for url in self.index_urls]

venv/Lib/site-packages/pip/_internal/models/selection_prefs.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from pip._internal.models.format_control import FormatControl
-
-
-# TODO: This needs Python 3.10's improved slots support for dataclasses
-# to be converted into a dataclass.
-class SelectionPreferences:
-    """
-    Encapsulates the candidate selection preferences for downloading
-    and installing files.
-    """
-
-    __slots__ = [
-        "allow_yanked",
-        "allow_all_prereleases",
-        "format_control",
-        "prefer_binary",
-        "ignore_requires_python",
-    ]
-
-    # Don't include an allow_yanked default value to make sure each call
-    # site considers whether yanked releases are allowed. This also causes
-    # that decision to be made explicit in the calling code, which helps
-    # people when reading the code.
-    def __init__(
-        self,
-        allow_yanked: bool,
-        allow_all_prereleases: bool = False,
-        format_control: FormatControl | None = None,
-        prefer_binary: bool = False,
-        ignore_requires_python: bool | None = None,
-    ) -> None:
-        """Create a SelectionPreferences object.
-
-        :param allow_yanked: Whether files marked as yanked (in the sense
-            of PEP 592) are permitted to be candidates for install.
-        :param format_control: A FormatControl object or None. Used to control
-            the selection of source packages / binary packages when consulting
-            the index and links.
-        :param prefer_binary: Whether to prefer an old, but valid, binary
-            dist over a new source dist.
-        :param ignore_requires_python: Whether to ignore incompatible
-            "Requires-Python" values in links. Defaults to False.
-        """
-        if ignore_requires_python is None:
-            ignore_requires_python = False
-
-        self.allow_yanked = allow_yanked
-        self.allow_all_prereleases = allow_all_prereleases
-        self.format_control = format_control
-        self.prefer_binary = prefer_binary
-        self.ignore_requires_python = ignore_requires_python

venv/Lib/site-packages/pip/_internal/models/target_python.py

@@ -1,122 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-from pip._vendor.packaging.tags import Tag
-
-from pip._internal.utils.compatibility_tags import get_supported, version_info_to_nodot
-from pip._internal.utils.misc import normalize_version_info
-
-
-class TargetPython:
-    """
-    Encapsulates the properties of a Python interpreter one is targeting
-    for a package install, download, etc.
-    """
-
-    __slots__ = [
-        "_given_py_version_info",
-        "abis",
-        "implementation",
-        "platforms",
-        "py_version",
-        "py_version_info",
-        "_valid_tags",
-        "_valid_tags_set",
-    ]
-
-    def __init__(
-        self,
-        platforms: list[str] | None = None,
-        py_version_info: tuple[int, ...] | None = None,
-        abis: list[str] | None = None,
-        implementation: str | None = None,
-    ) -> None:
-        """
-        :param platforms: A list of strings or None. If None, searches for
-            packages that are supported by the current system. Otherwise, will
-            find packages that can be built on the platforms passed in. These
-            packages will only be downloaded for distribution: they will
-            not be built locally.
-        :param py_version_info: An optional tuple of ints representing the
-            Python version information to use (e.g. `sys.version_info[:3]`).
-            This can have length 1, 2, or 3 when provided.
-        :param abis: A list of strings or None. This is passed to
-            compatibility_tags.py's get_supported() function as is.
-        :param implementation: A string or None. This is passed to
-            compatibility_tags.py's get_supported() function as is.
-        """
-        # Store the given py_version_info for when we call get_supported().
-        self._given_py_version_info = py_version_info
-
-        if py_version_info is None:
-            py_version_info = sys.version_info[:3]
-        else:
-            py_version_info = normalize_version_info(py_version_info)
-
-        py_version = ".".join(map(str, py_version_info[:2]))
-
-        self.abis = abis
-        self.implementation = implementation
-        self.platforms = platforms
-        self.py_version = py_version
-        self.py_version_info = py_version_info
-
-        # This is used to cache the return value of get_(un)sorted_tags.
-        self._valid_tags: list[Tag] | None = None
-        self._valid_tags_set: set[Tag] | None = None
-
-    def format_given(self) -> str:
-        """
-        Format the given, non-None attributes for display.
-        """
-        display_version = None
-        if self._given_py_version_info is not None:
-            display_version = ".".join(
-                str(part) for part in self._given_py_version_info
-            )
-
-        key_values = [
-            ("platforms", self.platforms),
-            ("version_info", display_version),
-            ("abis", self.abis),
-            ("implementation", self.implementation),
-        ]
-        return " ".join(
-            f"{key}={value!r}" for key, value in key_values if value is not None
-        )
-
-    def get_sorted_tags(self) -> list[Tag]:
-        """
-        Return the supported PEP 425 tags to check wheel candidates against.
-
-        The tags are returned in order of preference (most preferred first).
-        """
-        if self._valid_tags is None:
-            # Pass versions=None if no py_version_info was given since
-            # versions=None uses special default logic.
-            py_version_info = self._given_py_version_info
-            if py_version_info is None:
-                version = None
-            else:
-                version = version_info_to_nodot(py_version_info)
-
-            tags = get_supported(
-                version=version,
-                platforms=self.platforms,
-                abis=self.abis,
-                impl=self.implementation,
-            )
-            self._valid_tags = tags
-
-        return self._valid_tags
-
-    def get_unsorted_tags(self) -> set[Tag]:
-        """Exactly the same as get_sorted_tags, but returns a set.
-
-        This is important for performance.
-        """
-        if self._valid_tags_set is None:
-            self._valid_tags_set = set(self.get_sorted_tags())
-
-        return self._valid_tags_set

venv/Lib/site-packages/pip/_internal/models/wheel.py

@@ -1,141 +0,0 @@
-"""Represents a wheel file and provides access to the various parts of the
-name that have meaning.
-"""
-
-from __future__ import annotations
-
-import re
-from collections.abc import Iterable
-
-from pip._vendor.packaging.tags import Tag
-from pip._vendor.packaging.utils import BuildTag, parse_wheel_filename
-from pip._vendor.packaging.utils import (
-    InvalidWheelFilename as _PackagingInvalidWheelFilename,
-)
-
-from pip._internal.exceptions import InvalidWheelFilename
-from pip._internal.utils.deprecation import deprecated
-
-
-class Wheel:
-    """A wheel file"""
-
-    legacy_wheel_file_re = re.compile(
-        r"""^(?P<namever>(?P<name>[^\s-]+?)-(?P<ver>[^\s-]*?))
-        ((-(?P<build>\d[^-]*?))?-(?P<pyver>[^\s-]+?)-(?P<abi>[^\s-]+?)-(?P<plat>[^\s-]+?)
-        \.whl|\.dist-info)$""",
-        re.VERBOSE,
-    )
-
-    def __init__(self, filename: str) -> None:
-        self.filename = filename
-
-        # To make mypy happy specify type hints that can come from either
-        # parse_wheel_filename or the legacy_wheel_file_re match.
-        self.name: str
-        self._build_tag: BuildTag | None = None
-
-        try:
-            wheel_info = parse_wheel_filename(filename)
-            self.name, _version, self._build_tag, self.file_tags = wheel_info
-            self.version = str(_version)
-        except _PackagingInvalidWheelFilename as e:
-            # Check if the wheel filename is in the legacy format
-            legacy_wheel_info = self.legacy_wheel_file_re.match(filename)
-            if not legacy_wheel_info:
-                raise InvalidWheelFilename(e.args[0]) from None
-
-            deprecated(
-                reason=(
-                    f"Wheel filename {filename!r} is not correctly normalised. "
-                    "Future versions of pip will raise the following error:\n"
-                    f"{e.args[0]}\n\n"
-                ),
-                replacement=(
-                    "to rename the wheel to use a correctly normalised "
-                    "name (this may require updating the version in "
-                    "the project metadata)"
-                ),
-                gone_in="25.3",
-                issue=12938,
-            )
-
-            self.name = legacy_wheel_info.group("name").replace("_", "-")
-            self.version = legacy_wheel_info.group("ver").replace("_", "-")
-
-            # Generate the file tags from the legacy wheel filename
-            pyversions = legacy_wheel_info.group("pyver").split(".")
-            abis = legacy_wheel_info.group("abi").split(".")
-            plats = legacy_wheel_info.group("plat").split(".")
-            self.file_tags = frozenset(
-                Tag(interpreter=py, abi=abi, platform=plat)
-                for py in pyversions
-                for abi in abis
-                for plat in plats
-            )
-
-    @property
-    def build_tag(self) -> BuildTag:
-        if self._build_tag is not None:
-            return self._build_tag
-
-        # Parse the build tag from the legacy wheel filename
-        legacy_wheel_info = self.legacy_wheel_file_re.match(self.filename)
-        assert legacy_wheel_info is not None, "guaranteed by filename validation"
-        build_tag = legacy_wheel_info.group("build")
-        match = re.match(r"^(\d+)(.*)$", build_tag)
-        assert match is not None, "guaranteed by filename validation"
-        build_tag_groups = match.groups()
-        self._build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
-
-        return self._build_tag
-
-    def get_formatted_file_tags(self) -> list[str]:
-        """Return the wheel's tags as a sorted list of strings."""
-        return sorted(str(tag) for tag in self.file_tags)
-
-    def support_index_min(self, tags: list[Tag]) -> int:
-        """Return the lowest index that one of the wheel's file_tag combinations
-        achieves in the given list of supported tags.
-
-        For example, if there are 8 supported tags and one of the file tags
-        is first in the list, then return 0.
-
-        :param tags: the PEP 425 tags to check the wheel against, in order
-            with most preferred first.
-
-        :raises ValueError: If none of the wheel's file tags match one of
-            the supported tags.
-        """
-        try:
-            return next(i for i, t in enumerate(tags) if t in self.file_tags)
-        except StopIteration:
-            raise ValueError()
-
-    def find_most_preferred_tag(
-        self, tags: list[Tag], tag_to_priority: dict[Tag, int]
-    ) -> int:
-        """Return the priority of the most preferred tag that one of the wheel's file
-        tag combinations achieves in the given list of supported tags using the given
-        tag_to_priority mapping, where lower priorities are more-preferred.
-
-        This is used in place of support_index_min in some cases in order to avoid
-        an expensive linear scan of a large list of tags.
-
-        :param tags: the PEP 425 tags to check the wheel against.
-        :param tag_to_priority: a mapping from tag to priority of that tag, where
-            lower is more preferred.
-
-        :raises ValueError: If none of the wheel's file tags match one of
-            the supported tags.
-        """
-        return min(
-            tag_to_priority[tag] for tag in self.file_tags if tag in tag_to_priority
-        )
-
-    def supported(self, tags: Iterable[Tag]) -> bool:
-        """Return whether the wheel is compatible with one of the given tags.
-
-        :param tags: the PEP 425 tags to check the wheel against.
-        """
-        return not self.file_tags.isdisjoint(tags)

venv/Lib/site-packages/pip/_internal/network/__init__.py

@@ -1 +0,0 @@
-"""Contains purely network-related utilities."""