@scrypted/server 0.0.141 → 0.0.145

package/.venv/lib/python3.9/site-packages/pip/_internal/metadata/base.py

@@ -1,330 +0,0 @@
-import email.message
-import json
-import logging
-import re
-import zipfile
-from typing import (
-    IO,
-    TYPE_CHECKING,
-    Collection,
-    Container,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Union,
-)
-
-from pip._vendor.packaging.requirements import Requirement
-from pip._vendor.packaging.specifiers import InvalidSpecifier, SpecifierSet
-from pip._vendor.packaging.utils import NormalizedName
-from pip._vendor.packaging.version import LegacyVersion, Version
-
-from pip._internal.models.direct_url import (
-    DIRECT_URL_METADATA_NAME,
-    DirectUrl,
-    DirectUrlValidationError,
-)
-from pip._internal.utils.compat import stdlib_pkgs  # TODO: Move definition here.
-from pip._internal.utils.egg_link import egg_link_path_from_sys_path
-from pip._internal.utils.urls import url_to_path
-
-if TYPE_CHECKING:
-    from typing import Protocol
-else:
-    Protocol = object
-
-DistributionVersion = Union[LegacyVersion, Version]
-
-logger = logging.getLogger(__name__)
-
-
-class BaseEntryPoint(Protocol):
-    @property
-    def name(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def value(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def group(self) -> str:
-        raise NotImplementedError()
-
-
-class BaseDistribution(Protocol):
-    def __repr__(self) -> str:
-        return f"{self.raw_name} {self.version} ({self.location})"
-
-    def __str__(self) -> str:
-        return f"{self.raw_name} {self.version}"
-
-    @property
-    def location(self) -> Optional[str]:
-        """Where the distribution is loaded from.
-
-        A string value is not necessarily a filesystem path, since distributions
-        can be loaded from other sources, e.g. arbitrary zip archives. ``None``
-        means the distribution is created in-memory.
-
-        Do not canonicalize this value with e.g. ``pathlib.Path.resolve()``. If
-        this is a symbolic link, we want to preserve the relative path between
-        it and files in the distribution.
-        """
-        raise NotImplementedError()
-
-    @property
-    def editable_project_location(self) -> Optional[str]:
-        """The project location for editable distributions.
-
-        This is the directory where pyproject.toml or setup.py is located.
-        None if the distribution is not installed in editable mode.
-        """
-        # TODO: this property is relatively costly to compute, memoize it ?
-        direct_url = self.direct_url
-        if direct_url:
-            if direct_url.is_local_editable():
-                return url_to_path(direct_url.url)
-        else:
-            # Search for an .egg-link file by walking sys.path, as it was
-            # done before by dist_is_editable().
-            egg_link_path = egg_link_path_from_sys_path(self.raw_name)
-            if egg_link_path:
-                # TODO: get project location from second line of egg_link file
-                #       (https://github.com/pypa/pip/issues/10243)
-                return self.location
-        return None
-
-    @property
-    def info_directory(self) -> Optional[str]:
-        """Location of the .[egg|dist]-info directory.
-
-        Similarly to ``location``, a string value is not necessarily a
-        filesystem path. ``None`` means the distribution is created in-memory.
-
-        For a modern .dist-info installation on disk, this should be something
-        like ``{location}/{raw_name}-{version}.dist-info``.
-
-        Do not canonicalize this value with e.g. ``pathlib.Path.resolve()``. If
-        this is a symbolic link, we want to preserve the relative path between
-        it and other files in the distribution.
-        """
-        raise NotImplementedError()
-
-    @property
-    def canonical_name(self) -> NormalizedName:
-        raise NotImplementedError()
-
-    @property
-    def version(self) -> DistributionVersion:
-        raise NotImplementedError()
-
-    @property
-    def direct_url(self) -> Optional[DirectUrl]:
-        """Obtain a DirectUrl from this distribution.
-
-        Returns None if the distribution has no `direct_url.json` metadata,
-        or if `direct_url.json` is invalid.
-        """
-        try:
-            content = self.read_text(DIRECT_URL_METADATA_NAME)
-        except FileNotFoundError:
-            return None
-        try:
-            return DirectUrl.from_json(content)
-        except (
-            UnicodeDecodeError,
-            json.JSONDecodeError,
-            DirectUrlValidationError,
-        ) as e:
-            logger.warning(
-                "Error parsing %s for %s: %s",
-                DIRECT_URL_METADATA_NAME,
-                self.canonical_name,
-                e,
-            )
-            return None
-
-    @property
-    def installer(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def editable(self) -> bool:
-        return bool(self.editable_project_location)
-
-    @property
-    def local(self) -> bool:
-        raise NotImplementedError()
-
-    @property
-    def in_usersite(self) -> bool:
-        raise NotImplementedError()
-
-    @property
-    def in_site_packages(self) -> bool:
-        raise NotImplementedError()
-
-    def read_text(self, name: str) -> str:
-        """Read a file in the .dist-info (or .egg-info) directory.
-
-        Should raise ``FileNotFoundError`` if ``name`` does not exist in the
-        metadata directory.
-        """
-        raise NotImplementedError()
-
-    def iter_entry_points(self) -> Iterable[BaseEntryPoint]:
-        raise NotImplementedError()
-
-    @property
-    def metadata(self) -> email.message.Message:
-        """Metadata of distribution parsed from e.g. METADATA or PKG-INFO."""
-        raise NotImplementedError()
-
-    @property
-    def metadata_version(self) -> Optional[str]:
-        """Value of "Metadata-Version:" in distribution metadata, if available."""
-        return self.metadata.get("Metadata-Version")
-
-    @property
-    def raw_name(self) -> str:
-        """Value of "Name:" in distribution metadata."""
-        # The metadata should NEVER be missing the Name: key, but if it somehow
-        # does, fall back to the known canonical name.
-        return self.metadata.get("Name", self.canonical_name)
-
-    @property
-    def requires_python(self) -> SpecifierSet:
-        """Value of "Requires-Python:" in distribution metadata.
-
-        If the key does not exist or contains an invalid value, an empty
-        SpecifierSet should be returned.
-        """
-        value = self.metadata.get("Requires-Python")
-        if value is None:
-            return SpecifierSet()
-        try:
-            # Convert to str to satisfy the type checker; this can be a Header object.
-            spec = SpecifierSet(str(value))
-        except InvalidSpecifier as e:
-            message = "Package %r has an invalid Requires-Python: %s"
-            logger.warning(message, self.raw_name, e)
-            return SpecifierSet()
-        return spec
-
-    def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:
-        """Dependencies of this distribution.
-
-        For modern .dist-info distributions, this is the collection of
-        "Requires-Dist:" entries in distribution metadata.
-        """
-        raise NotImplementedError()
-
-    def iter_provided_extras(self) -> Iterable[str]:
-        """Extras provided by this distribution.
-
-        For modern .dist-info distributions, this is the collection of
-        "Provides-Extra:" entries in distribution metadata.
-        """
-        raise NotImplementedError()
-
-
-class BaseEnvironment:
-    """An environment containing distributions to introspect."""
-
-    @classmethod
-    def default(cls) -> "BaseEnvironment":
-        raise NotImplementedError()
-
-    @classmethod
-    def from_paths(cls, paths: Optional[List[str]]) -> "BaseEnvironment":
-        raise NotImplementedError()
-
-    def get_distribution(self, name: str) -> Optional["BaseDistribution"]:
-        """Given a requirement name, return the installed distributions."""
-        raise NotImplementedError()
-
-    def _iter_distributions(self) -> Iterator["BaseDistribution"]:
-        """Iterate through installed distributions.
-
-        This function should be implemented by subclass, but never called
-        directly. Use the public ``iter_distribution()`` instead, which
-        implements additional logic to make sure the distributions are valid.
-        """
-        raise NotImplementedError()
-
-    def iter_distributions(self) -> Iterator["BaseDistribution"]:
-        """Iterate through installed distributions."""
-        for dist in self._iter_distributions():
-            # Make sure the distribution actually comes from a valid Python
-            # packaging distribution. Pip's AdjacentTempDirectory leaves folders
-            # e.g. ``~atplotlib.dist-info`` if cleanup was interrupted. The
-            # valid project name pattern is taken from PEP 508.
-            project_name_valid = re.match(
-                r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$",
-                dist.canonical_name,
-                flags=re.IGNORECASE,
-            )
-            if not project_name_valid:
-                logger.warning(
-                    "Ignoring invalid distribution %s (%s)",
-                    dist.canonical_name,
-                    dist.location,
-                )
-                continue
-            yield dist
-
-    def iter_installed_distributions(
-        self,
-        local_only: bool = True,
-        skip: Container[str] = stdlib_pkgs,
-        include_editables: bool = True,
-        editables_only: bool = False,
-        user_only: bool = False,
-    ) -> Iterator[BaseDistribution]:
-        """Return a list of installed distributions.
-
-        :param local_only: If True (default), only return installations
-        local to the current virtualenv, if in a virtualenv.
-        :param skip: An iterable of canonicalized project names to ignore;
-            defaults to ``stdlib_pkgs``.
-        :param include_editables: If False, don't report editables.
-        :param editables_only: If True, only report editables.
-        :param user_only: If True, only report installations in the user
-        site directory.
-        """
-        it = self.iter_distributions()
-        if local_only:
-            it = (d for d in it if d.local)
-        if not include_editables:
-            it = (d for d in it if not d.editable)
-        if editables_only:
-            it = (d for d in it if d.editable)
-        if user_only:
-            it = (d for d in it if d.in_usersite)
-        return (d for d in it if d.canonical_name not in skip)
-
-
-class Wheel(Protocol):
-    location: str
-
-    def as_zipfile(self) -> zipfile.ZipFile:
-        raise NotImplementedError()
-
-
-class FilesystemWheel(Wheel):
-    def __init__(self, location: str) -> None:
-        self.location = location
-
-    def as_zipfile(self) -> zipfile.ZipFile:
-        return zipfile.ZipFile(self.location, allowZip64=True)
-
-
-class MemoryWheel(Wheel):
-    def __init__(self, location: str, stream: IO[bytes]) -> None:
-        self.location = location
-        self.stream = stream
-
-    def as_zipfile(self) -> zipfile.ZipFile:
-        return zipfile.ZipFile(self.stream, allowZip64=True)

package/.venv/lib/python3.9/site-packages/pip/_internal/metadata/pkg_resources.py

@@ -1,146 +0,0 @@
-import email.message
-import logging
-from typing import Collection, Iterable, Iterator, List, NamedTuple, Optional
-
-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 parse as parse_version
-
-from pip._internal.utils import misc  # TODO: Move definition here.
-from pip._internal.utils.packaging import get_installer, get_metadata
-from pip._internal.utils.wheel import pkg_resources_distribution_for_wheel
-
-from .base import (
-    BaseDistribution,
-    BaseEntryPoint,
-    BaseEnvironment,
-    DistributionVersion,
-    Wheel,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class EntryPoint(NamedTuple):
-    name: str
-    value: str
-    group: str
-
-
-class Distribution(BaseDistribution):
-    def __init__(self, dist: pkg_resources.Distribution) -> None:
-        self._dist = dist
-
-    @classmethod
-    def from_wheel(cls, wheel: Wheel, name: str) -> "Distribution":
-        with wheel.as_zipfile() as zf:
-            dist = pkg_resources_distribution_for_wheel(zf, name, wheel.location)
-        return cls(dist)
-
-    @property
-    def location(self) -> Optional[str]:
-        return self._dist.location
-
-    @property
-    def info_directory(self) -> Optional[str]:
-        return self._dist.egg_info
-
-    @property
-    def canonical_name(self) -> NormalizedName:
-        return canonicalize_name(self._dist.project_name)
-
-    @property
-    def version(self) -> DistributionVersion:
-        return parse_version(self._dist.version)
-
-    @property
-    def installer(self) -> str:
-        return get_installer(self._dist)
-
-    @property
-    def local(self) -> bool:
-        return misc.dist_is_local(self._dist)
-
-    @property
-    def in_usersite(self) -> bool:
-        return misc.dist_in_usersite(self._dist)
-
-    @property
-    def in_site_packages(self) -> bool:
-        return misc.dist_in_site_packages(self._dist)
-
-    def read_text(self, name: str) -> str:
-        if not self._dist.has_metadata(name):
-            raise FileNotFoundError(name)
-        return self._dist.get_metadata(name)
-
-    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)
-
-    @property
-    def metadata(self) -> email.message.Message:
-        return get_metadata(self._dist)
-
-    def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:
-        if extras:  # pkg_resources raises on invalid extras, so we sanitize.
-            extras = frozenset(extras).intersection(self._dist.extras)
-        return self._dist.requires(extras)
-
-    def iter_provided_extras(self) -> Iterable[str]:
-        return self._dist.extras
-
-
-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: Optional[List[str]]) -> BaseEnvironment:
-        return cls(pkg_resources.WorkingSet(paths))
-
-    def _search_distribution(self, name: str) -> Optional[BaseDistribution]:
-        """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_distributions():
-            if dist.canonical_name == canonical_name:
-                return dist
-        return None
-
-    def get_distribution(self, name: str) -> Optional[BaseDistribution]:
-
-        # 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)
-
-    def _iter_distributions(self) -> Iterator[BaseDistribution]:
-        for dist in self._ws:
-            yield Distribution(dist)

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

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

package/.venv/lib/python3.9/site-packages/pip/_internal/models/candidate.py

@@ -1,34 +0,0 @@
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip._internal.models.link import Link
-from pip._internal.utils.models import KeyBasedCompareMixin
-
-
-class InstallationCandidate(KeyBasedCompareMixin):
-    """Represents a potential "candidate" for installation."""
-
-    __slots__ = ["name", "version", "link"]
-
-    def __init__(self, name: str, version: str, link: Link) -> None:
-        self.name = name
-        self.version = parse_version(version)
-        self.link = link
-
-        super().__init__(
-            key=(self.name, self.version, self.link),
-            defining_class=InstallationCandidate,
-        )
-
-    def __repr__(self) -> str:
-        return "<InstallationCandidate({!r}, {!r}, {!r})>".format(
-            self.name,
-            self.version,
-            self.link,
-        )
-
-    def __str__(self) -> str:
-        return "{!r} candidate (version {} at {})".format(
-            self.name,
-            self.version,
-            self.link,
-        )