@scrypted/arlo 0.11.26 → 0.11.28

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

@@ -1,256 +0,0 @@
-import email.message
-import email.parser
-import logging
-import os
-import pathlib
-import zipfile
-from typing import Collection, Iterable, Iterator, List, Mapping, 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.exceptions import InvalidWheel, NoneMetadataError, UnsupportedWheel
-from pip._internal.utils.misc import display_path
-from pip._internal.utils.wheel import parse_wheel, read_wheel_metadata_file
-
-from .base import (
-    BaseDistribution,
-    BaseEntryPoint,
-    BaseEnvironment,
-    DistributionVersion,
-    InfoPath,
-    Wheel,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class EntryPoint(NamedTuple):
-    name: str
-    value: str
-    group: str
-
-
-class WheelMetadata:
-    """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
-
-    @classmethod
-    def from_directory(cls, directory: str) -> "Distribution":
-        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_wheel(cls, wheel: Wheel, name: str) -> "Distribution":
-        """Load the distribution from a given wheel.
-
-        :raises InvalidWheel: Whenever loading of the wheel causes a
-            :py:exc:`zipfile.BadZipFile` exception to be thrown.
-        :raises UnsupportedWheel: If the wheel is a valid zip, but malformed
-            internally.
-        """
-        try:
-            with wheel.as_zipfile() as zf:
-                info_dir, _ = parse_wheel(zf, name)
-                metadata_text = {
-                    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=WheelMetadata(metadata_text, wheel.location),
-            project_name=name,
-        )
-        return cls(dist)
-
-    @property
-    def location(self) -> Optional[str]:
-        return self._dist.location
-
-    @property
-    def info_location(self) -> Optional[str]:
-        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) -> DistributionVersion:
-        return parse_version(self._dist.version)
-
-    def is_file(self, path: InfoPath) -> bool:
-        return self._dist.has_metadata(str(path))
-
-    def iterdir(self, path: InfoPath) -> Iterator[pathlib.PurePosixPath]:
-        name = str(path)
-        if not self._dist.has_metadata(name):
-            raise FileNotFoundError(name)
-        if not self._dist.isdir(name):
-            raise NotADirectoryError(name)
-        for child in self._dist.metadata_listdir(name):
-            yield pathlib.PurePosixPath(path, child)
-
-    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)
-
-    @property
-    def metadata(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:  # 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.10/site-packages/pip/_internal/models/__init__.py

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

package/venv/lib/python3.10/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,
-        )

package/venv/lib/python3.10/site-packages/pip/_internal/models/direct_url.py

@@ -1,220 +0,0 @@
-""" PEP 610 """
-import json
-import re
-import urllib.parse
-from typing import Any, Dict, Iterable, Optional, Type, 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: Optional[T] = None
-) -> Optional[T]:
-    """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(
-            "{!r} has unexpected type for {} (expected {})".format(
-                value, key, expected_type
-            )
-        )
-    return value
-
-
-def _get_required(
-    d: Dict[str, Any], expected_type: Type[T], key: str, default: Optional[T] = 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[Optional["InfoType"]]) -> "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}
-
-
-class VcsInfo:
-    name = "vcs_info"
-
-    def __init__(
-        self,
-        vcs: str,
-        commit_id: str,
-        requested_revision: Optional[str] = None,
-        resolved_revision: Optional[str] = None,
-        resolved_revision_type: Optional[str] = None,
-    ) -> None:
-        self.vcs = vcs
-        self.requested_revision = requested_revision
-        self.commit_id = commit_id
-        self.resolved_revision = resolved_revision
-        self.resolved_revision_type = resolved_revision_type
-
-    @classmethod
-    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["VcsInfo"]:
-        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"),
-            resolved_revision=_get(d, str, "resolved_revision"),
-            resolved_revision_type=_get(d, str, "resolved_revision_type"),
-        )
-
-    def _to_dict(self) -> Dict[str, Any]:
-        return _filter_none(
-            vcs=self.vcs,
-            requested_revision=self.requested_revision,
-            commit_id=self.commit_id,
-            resolved_revision=self.resolved_revision,
-            resolved_revision_type=self.resolved_revision_type,
-        )
-
-
-class ArchiveInfo:
-    name = "archive_info"
-
-    def __init__(
-        self,
-        hash: Optional[str] = None,
-    ) -> None:
-        self.hash = hash
-
-    @classmethod
-    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["ArchiveInfo"]:
-        if d is None:
-            return None
-        return cls(hash=_get(d, str, "hash"))
-
-    def _to_dict(self) -> Dict[str, Any]:
-        return _filter_none(hash=self.hash)
-
-
-class DirInfo:
-    name = "dir_info"
-
-    def __init__(
-        self,
-        editable: bool = False,
-    ) -> None:
-        self.editable = editable
-
-    @classmethod
-    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["DirInfo"]:
-        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]
-
-
-class DirectUrl:
-    def __init__(
-        self,
-        url: str,
-        info: InfoType,
-        subdirectory: Optional[str] = None,
-    ) -> None:
-        self.url = url
-        self.info = info
-        self.subdirectory = subdirectory
-
-    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

package/venv/lib/python3.10/site-packages/pip/_internal/models/format_control.py

@@ -1,80 +0,0 @@
-from typing import FrozenSet, Optional, Set
-
-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: Optional[Set[str]] = None,
-        only_binary: Optional[Set[str]] = 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 "{}({}, {})".format(
-            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,
-        )

package/venv/lib/python3.10/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"
-)