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

venv/Lib/site-packages/pip/_internal/metadata/pkg_resources.py

@@ -1,298 +0,0 @@
-from __future__ import annotations
-
-import email.message
-import email.parser
-import logging
-import os
-import zipfile
-from collections.abc import Collection, Iterable, Iterator, Mapping
-from typing import (
-    NamedTuple,
-)
-
-from pip._vendor import pkg_resources
-from pip._vendor.packaging.requirements import Requirement
-from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
-from pip._vendor.packaging.version import Version
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip._internal.exceptions import InvalidWheel, NoneMetadataError, UnsupportedWheel
-from pip._internal.utils.egg_link import egg_link_path_from_location
-from pip._internal.utils.misc import display_path, normalize_path
-from pip._internal.utils.wheel import parse_wheel, read_wheel_metadata_file
-
-from .base import (
-    BaseDistribution,
-    BaseEntryPoint,
-    BaseEnvironment,
-    InfoPath,
-    Wheel,
-)
-
-__all__ = ["NAME", "Distribution", "Environment"]
-
-logger = logging.getLogger(__name__)
-
-NAME = "pkg_resources"
-
-
-class EntryPoint(NamedTuple):
-    name: str
-    value: str
-    group: str
-
-
-class InMemoryMetadata:
-    """IMetadataProvider that reads metadata files from a dictionary.
-
-    This also maps metadata decoding exceptions to our internal exception type.
-    """
-
-    def __init__(self, metadata: Mapping[str, bytes], wheel_name: str) -> None:
-        self._metadata = metadata
-        self._wheel_name = wheel_name
-
-    def has_metadata(self, name: str) -> bool:
-        return name in self._metadata
-
-    def get_metadata(self, name: str) -> str:
-        try:
-            return self._metadata[name].decode()
-        except UnicodeDecodeError as e:
-            # Augment the default error with the origin of the file.
-            raise UnsupportedWheel(
-                f"Error decoding metadata for {self._wheel_name}: {e} in {name} file"
-            )
-
-    def get_metadata_lines(self, name: str) -> Iterable[str]:
-        return pkg_resources.yield_lines(self.get_metadata(name))
-
-    def metadata_isdir(self, name: str) -> bool:
-        return False
-
-    def metadata_listdir(self, name: str) -> list[str]:
-        return []
-
-    def run_script(self, script_name: str, namespace: str) -> None:
-        pass
-
-
-class Distribution(BaseDistribution):
-    def __init__(self, dist: pkg_resources.Distribution) -> None:
-        self._dist = dist
-        # This is populated lazily, to avoid loading metadata for all possible
-        # distributions eagerly.
-        self.__extra_mapping: Mapping[NormalizedName, str] | None = None
-
-    @property
-    def _extra_mapping(self) -> Mapping[NormalizedName, str]:
-        if self.__extra_mapping is None:
-            self.__extra_mapping = {
-                canonicalize_name(extra): extra for extra in self._dist.extras
-            }
-
-        return self.__extra_mapping
-
-    @classmethod
-    def from_directory(cls, directory: str) -> BaseDistribution:
-        dist_dir = directory.rstrip(os.sep)
-
-        # Build a PathMetadata object, from path to metadata. :wink:
-        base_dir, dist_dir_name = os.path.split(dist_dir)
-        metadata = pkg_resources.PathMetadata(base_dir, dist_dir)
-
-        # Determine the correct Distribution object type.
-        if dist_dir.endswith(".egg-info"):
-            dist_cls = pkg_resources.Distribution
-            dist_name = os.path.splitext(dist_dir_name)[0]
-        else:
-            assert dist_dir.endswith(".dist-info")
-            dist_cls = pkg_resources.DistInfoDistribution
-            dist_name = os.path.splitext(dist_dir_name)[0].split("-")[0]
-
-        dist = dist_cls(base_dir, project_name=dist_name, metadata=metadata)
-        return cls(dist)
-
-    @classmethod
-    def from_metadata_file_contents(
-        cls,
-        metadata_contents: bytes,
-        filename: str,
-        project_name: str,
-    ) -> BaseDistribution:
-        metadata_dict = {
-            "METADATA": metadata_contents,
-        }
-        dist = pkg_resources.DistInfoDistribution(
-            location=filename,
-            metadata=InMemoryMetadata(metadata_dict, filename),
-            project_name=project_name,
-        )
-        return cls(dist)
-
-    @classmethod
-    def from_wheel(cls, wheel: Wheel, name: str) -> BaseDistribution:
-        try:
-            with wheel.as_zipfile() as zf:
-                info_dir, _ = parse_wheel(zf, name)
-                metadata_dict = {
-                    path.split("/", 1)[-1]: read_wheel_metadata_file(zf, path)
-                    for path in zf.namelist()
-                    if path.startswith(f"{info_dir}/")
-                }
-        except zipfile.BadZipFile as e:
-            raise InvalidWheel(wheel.location, name) from e
-        except UnsupportedWheel as e:
-            raise UnsupportedWheel(f"{name} has an invalid wheel, {e}")
-        dist = pkg_resources.DistInfoDistribution(
-            location=wheel.location,
-            metadata=InMemoryMetadata(metadata_dict, wheel.location),
-            project_name=name,
-        )
-        return cls(dist)
-
-    @property
-    def location(self) -> str | None:
-        return self._dist.location
-
-    @property
-    def installed_location(self) -> str | None:
-        egg_link = egg_link_path_from_location(self.raw_name)
-        if egg_link:
-            location = egg_link
-        elif self.location:
-            location = self.location
-        else:
-            return None
-        return normalize_path(location)
-
-    @property
-    def info_location(self) -> str | None:
-        return self._dist.egg_info
-
-    @property
-    def installed_by_distutils(self) -> bool:
-        # A distutils-installed distribution is provided by FileMetadata. This
-        # provider has a "path" attribute not present anywhere else. Not the
-        # best introspection logic, but pip has been doing this for a long time.
-        try:
-            return bool(self._dist._provider.path)
-        except AttributeError:
-            return False
-
-    @property
-    def canonical_name(self) -> NormalizedName:
-        return canonicalize_name(self._dist.project_name)
-
-    @property
-    def version(self) -> Version:
-        return parse_version(self._dist.version)
-
-    @property
-    def raw_version(self) -> str:
-        return self._dist.version
-
-    def is_file(self, path: InfoPath) -> bool:
-        return self._dist.has_metadata(str(path))
-
-    def iter_distutils_script_names(self) -> Iterator[str]:
-        yield from self._dist.metadata_listdir("scripts")
-
-    def read_text(self, path: InfoPath) -> str:
-        name = str(path)
-        if not self._dist.has_metadata(name):
-            raise FileNotFoundError(name)
-        content = self._dist.get_metadata(name)
-        if content is None:
-            raise NoneMetadataError(self, name)
-        return content
-
-    def iter_entry_points(self) -> Iterable[BaseEntryPoint]:
-        for group, entries in self._dist.get_entry_map().items():
-            for name, entry_point in entries.items():
-                name, _, value = str(entry_point).partition("=")
-                yield EntryPoint(name=name.strip(), value=value.strip(), group=group)
-
-    def _metadata_impl(self) -> email.message.Message:
-        """
-        :raises NoneMetadataError: if the distribution reports `has_metadata()`
-            True but `get_metadata()` returns None.
-        """
-        if isinstance(self._dist, pkg_resources.DistInfoDistribution):
-            metadata_name = "METADATA"
-        else:
-            metadata_name = "PKG-INFO"
-        try:
-            metadata = self.read_text(metadata_name)
-        except FileNotFoundError:
-            if self.location:
-                displaying_path = display_path(self.location)
-            else:
-                displaying_path = repr(self.location)
-            logger.warning("No metadata found in %s", displaying_path)
-            metadata = ""
-        feed_parser = email.parser.FeedParser()
-        feed_parser.feed(metadata)
-        return feed_parser.close()
-
-    def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:
-        if extras:
-            relevant_extras = set(self._extra_mapping) & set(
-                map(canonicalize_name, extras)
-            )
-            extras = [self._extra_mapping[extra] for extra in relevant_extras]
-        return self._dist.requires(extras)
-
-    def iter_provided_extras(self) -> Iterable[NormalizedName]:
-        return self._extra_mapping.keys()
-
-
-class Environment(BaseEnvironment):
-    def __init__(self, ws: pkg_resources.WorkingSet) -> None:
-        self._ws = ws
-
-    @classmethod
-    def default(cls) -> BaseEnvironment:
-        return cls(pkg_resources.working_set)
-
-    @classmethod
-    def from_paths(cls, paths: list[str] | None) -> BaseEnvironment:
-        return cls(pkg_resources.WorkingSet(paths))
-
-    def _iter_distributions(self) -> Iterator[BaseDistribution]:
-        for dist in self._ws:
-            yield Distribution(dist)
-
-    def _search_distribution(self, name: str) -> BaseDistribution | None:
-        """Find a distribution matching the ``name`` in the environment.
-
-        This searches from *all* distributions available in the environment, to
-        match the behavior of ``pkg_resources.get_distribution()``.
-        """
-        canonical_name = canonicalize_name(name)
-        for dist in self.iter_all_distributions():
-            if dist.canonical_name == canonical_name:
-                return dist
-        return None
-
-    def get_distribution(self, name: str) -> BaseDistribution | None:
-        # Search the distribution by looking through the working set.
-        dist = self._search_distribution(name)
-        if dist:
-            return dist
-
-        # If distribution could not be found, call working_set.require to
-        # update the working set, and try to find the distribution again.
-        # This might happen for e.g. when you install a package twice, once
-        # using setup.py develop and again using setup.py install. Now when
-        # running pip uninstall twice, the package gets removed from the
-        # working set in the first uninstall, so we have to populate the
-        # working set again so that pip knows about it and the packages gets
-        # picked up and is successfully uninstalled the second time too.
-        try:
-            # We didn't pass in any version specifiers, so this can never
-            # raise pkg_resources.VersionConflict.
-            self._ws.require(name)
-        except pkg_resources.DistributionNotFound:
-            return None
-        return self._search_distribution(name)

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

@@ -1 +0,0 @@
-"""A package that contains models that represent entities."""

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

@@ -1,25 +0,0 @@
-from dataclasses import dataclass
-
-from pip._vendor.packaging.version import Version
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip._internal.models.link import Link
-
-
-@dataclass(frozen=True)
-class InstallationCandidate:
-    """Represents a potential "candidate" for installation."""
-
-    __slots__ = ["name", "version", "link"]
-
-    name: str
-    version: Version
-    link: Link
-
-    def __init__(self, name: str, version: str, link: Link) -> None:
-        object.__setattr__(self, "name", name)
-        object.__setattr__(self, "version", parse_version(version))
-        object.__setattr__(self, "link", link)
-
-    def __str__(self) -> str:
-        return f"{self.name!r} candidate (version {self.version} at {self.link})"

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

@@ -1,227 +0,0 @@
-"""PEP 610"""
-
-from __future__ import annotations
-
-import json
-import re
-import urllib.parse
-from collections.abc import Iterable
-from dataclasses import dataclass
-from typing import Any, ClassVar, TypeVar, Union
-
-__all__ = [
-    "DirectUrl",
-    "DirectUrlValidationError",
-    "DirInfo",
-    "ArchiveInfo",
-    "VcsInfo",
-]
-
-T = TypeVar("T")
-
-DIRECT_URL_METADATA_NAME = "direct_url.json"
-ENV_VAR_RE = re.compile(r"^\$\{[A-Za-z0-9-_]+\}(:\$\{[A-Za-z0-9-_]+\})?$")
-
-
-class DirectUrlValidationError(Exception):
-    pass
-
-
-def _get(
-    d: dict[str, Any], expected_type: type[T], key: str, default: T | None = None
-) -> T | None:
-    """Get value from dictionary and verify expected type."""
-    if key not in d:
-        return default
-    value = d[key]
-    if not isinstance(value, expected_type):
-        raise DirectUrlValidationError(
-            f"{value!r} has unexpected type for {key} (expected {expected_type})"
-        )
-    return value
-
-
-def _get_required(
-    d: dict[str, Any], expected_type: type[T], key: str, default: T | None = None
-) -> T:
-    value = _get(d, expected_type, key, default)
-    if value is None:
-        raise DirectUrlValidationError(f"{key} must have a value")
-    return value
-
-
-def _exactly_one_of(infos: Iterable[InfoType | None]) -> InfoType:
-    infos = [info for info in infos if info is not None]
-    if not infos:
-        raise DirectUrlValidationError(
-            "missing one of archive_info, dir_info, vcs_info"
-        )
-    if len(infos) > 1:
-        raise DirectUrlValidationError(
-            "more than one of archive_info, dir_info, vcs_info"
-        )
-    assert infos[0] is not None
-    return infos[0]
-
-
-def _filter_none(**kwargs: Any) -> dict[str, Any]:
-    """Make dict excluding None values."""
-    return {k: v for k, v in kwargs.items() if v is not None}
-
-
-@dataclass
-class VcsInfo:
-    name: ClassVar = "vcs_info"
-
-    vcs: str
-    commit_id: str
-    requested_revision: str | None = None
-
-    @classmethod
-    def _from_dict(cls, d: dict[str, Any] | None) -> VcsInfo | None:
-        if d is None:
-            return None
-        return cls(
-            vcs=_get_required(d, str, "vcs"),
-            commit_id=_get_required(d, str, "commit_id"),
-            requested_revision=_get(d, str, "requested_revision"),
-        )
-
-    def _to_dict(self) -> dict[str, Any]:
-        return _filter_none(
-            vcs=self.vcs,
-            requested_revision=self.requested_revision,
-            commit_id=self.commit_id,
-        )
-
-
-class ArchiveInfo:
-    name = "archive_info"
-
-    def __init__(
-        self,
-        hash: str | None = None,
-        hashes: dict[str, str] | None = None,
-    ) -> None:
-        # set hashes before hash, since the hash setter will further populate hashes
-        self.hashes = hashes
-        self.hash = hash
-
-    @property
-    def hash(self) -> str | None:
-        return self._hash
-
-    @hash.setter
-    def hash(self, value: str | None) -> None:
-        if value is not None:
-            # Auto-populate the hashes key to upgrade to the new format automatically.
-            # We don't back-populate the legacy hash key from hashes.
-            try:
-                hash_name, hash_value = value.split("=", 1)
-            except ValueError:
-                raise DirectUrlValidationError(
-                    f"invalid archive_info.hash format: {value!r}"
-                )
-            if self.hashes is None:
-                self.hashes = {hash_name: hash_value}
-            elif hash_name not in self.hashes:
-                self.hashes = self.hashes.copy()
-                self.hashes[hash_name] = hash_value
-        self._hash = value
-
-    @classmethod
-    def _from_dict(cls, d: dict[str, Any] | None) -> ArchiveInfo | None:
-        if d is None:
-            return None
-        return cls(hash=_get(d, str, "hash"), hashes=_get(d, dict, "hashes"))
-
-    def _to_dict(self) -> dict[str, Any]:
-        return _filter_none(hash=self.hash, hashes=self.hashes)
-
-
-@dataclass
-class DirInfo:
-    name: ClassVar = "dir_info"
-
-    editable: bool = False
-
-    @classmethod
-    def _from_dict(cls, d: dict[str, Any] | None) -> DirInfo | None:
-        if d is None:
-            return None
-        return cls(editable=_get_required(d, bool, "editable", default=False))
-
-    def _to_dict(self) -> dict[str, Any]:
-        return _filter_none(editable=self.editable or None)
-
-
-InfoType = Union[ArchiveInfo, DirInfo, VcsInfo]
-
-
-@dataclass
-class DirectUrl:
-    url: str
-    info: InfoType
-    subdirectory: str | None = None
-
-    def _remove_auth_from_netloc(self, netloc: str) -> str:
-        if "@" not in netloc:
-            return netloc
-        user_pass, netloc_no_user_pass = netloc.split("@", 1)
-        if (
-            isinstance(self.info, VcsInfo)
-            and self.info.vcs == "git"
-            and user_pass == "git"
-        ):
-            return netloc
-        if ENV_VAR_RE.match(user_pass):
-            return netloc
-        return netloc_no_user_pass
-
-    @property
-    def redacted_url(self) -> str:
-        """url with user:password part removed unless it is formed with
-        environment variables as specified in PEP 610, or it is ``git``
-        in the case of a git URL.
-        """
-        purl = urllib.parse.urlsplit(self.url)
-        netloc = self._remove_auth_from_netloc(purl.netloc)
-        surl = urllib.parse.urlunsplit(
-            (purl.scheme, netloc, purl.path, purl.query, purl.fragment)
-        )
-        return surl
-
-    def validate(self) -> None:
-        self.from_dict(self.to_dict())
-
-    @classmethod
-    def from_dict(cls, d: dict[str, Any]) -> DirectUrl:
-        return DirectUrl(
-            url=_get_required(d, str, "url"),
-            subdirectory=_get(d, str, "subdirectory"),
-            info=_exactly_one_of(
-                [
-                    ArchiveInfo._from_dict(_get(d, dict, "archive_info")),
-                    DirInfo._from_dict(_get(d, dict, "dir_info")),
-                    VcsInfo._from_dict(_get(d, dict, "vcs_info")),
-                ]
-            ),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        res = _filter_none(
-            url=self.redacted_url,
-            subdirectory=self.subdirectory,
-        )
-        res[self.info.name] = self.info._to_dict()
-        return res
-
-    @classmethod
-    def from_json(cls, s: str) -> DirectUrl:
-        return cls.from_dict(json.loads(s))
-
-    def to_json(self) -> str:
-        return json.dumps(self.to_dict(), sort_keys=True)
-
-    def is_local_editable(self) -> bool:
-        return isinstance(self.info, DirInfo) and self.info.editable

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

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.exceptions import CommandError
-
-
-class FormatControl:
-    """Helper for managing formats from which a package can be installed."""
-
-    __slots__ = ["no_binary", "only_binary"]
-
-    def __init__(
-        self,
-        no_binary: set[str] | None = None,
-        only_binary: set[str] | None = None,
-    ) -> None:
-        if no_binary is None:
-            no_binary = set()
-        if only_binary is None:
-            only_binary = set()
-
-        self.no_binary = no_binary
-        self.only_binary = only_binary
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
-            return NotImplemented
-
-        if self.__slots__ != other.__slots__:
-            return False
-
-        return all(getattr(self, k) == getattr(other, k) for k in self.__slots__)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.no_binary}, {self.only_binary})"
-
-    @staticmethod
-    def handle_mutual_excludes(value: str, target: set[str], other: set[str]) -> None:
-        if value.startswith("-"):
-            raise CommandError(
-                "--no-binary / --only-binary option requires 1 argument."
-            )
-        new = value.split(",")
-        while ":all:" in new:
-            other.clear()
-            target.clear()
-            target.add(":all:")
-            del new[: new.index(":all:") + 1]
-            # Without a none, we want to discard everything as :all: covers it
-            if ":none:" not in new:
-                return
-        for name in new:
-            if name == ":none:":
-                target.clear()
-                continue
-            name = canonicalize_name(name)
-            other.discard(name)
-            target.add(name)
-
-    def get_allowed_formats(self, canonical_name: str) -> frozenset[str]:
-        result = {"binary", "source"}
-        if canonical_name in self.only_binary:
-            result.discard("source")
-        elif canonical_name in self.no_binary:
-            result.discard("binary")
-        elif ":all:" in self.only_binary:
-            result.discard("source")
-        elif ":all:" in self.no_binary:
-            result.discard("binary")
-        return frozenset(result)
-
-    def disallow_binaries(self) -> None:
-        self.handle_mutual_excludes(
-            ":all:",
-            self.no_binary,
-            self.only_binary,
-        )

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

@@ -1,28 +0,0 @@
-import urllib.parse
-
-
-class PackageIndex:
-    """Represents a Package Index and provides easier access to endpoints"""
-
-    __slots__ = ["url", "netloc", "simple_url", "pypi_url", "file_storage_domain"]
-
-    def __init__(self, url: str, file_storage_domain: str) -> None:
-        super().__init__()
-        self.url = url
-        self.netloc = urllib.parse.urlsplit(url).netloc
-        self.simple_url = self._url_for_path("simple")
-        self.pypi_url = self._url_for_path("pypi")
-
-        # This is part of a temporary hack used to block installs of PyPI
-        # packages which depend on external urls only necessary until PyPI can
-        # block such packages themselves
-        self.file_storage_domain = file_storage_domain
-
-    def _url_for_path(self, path: str) -> str:
-        return urllib.parse.urljoin(self.url, path)
-
-
-PyPI = PackageIndex("https://pypi.org/", file_storage_domain="files.pythonhosted.org")
-TestPyPI = PackageIndex(
-    "https://test.pypi.org/", file_storage_domain="test-files.pythonhosted.org"
-)