@scrypted/server 0.0.141 → 0.0.145

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

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

@@ -1,288 +0,0 @@
-import functools
-import logging
-import os
-import posixpath
-import re
-import urllib.parse
-from typing import TYPE_CHECKING, Dict, List, NamedTuple, Optional, Tuple, Union
-
-from pip._internal.utils.filetypes import WHEEL_EXTENSION
-from pip._internal.utils.hashes import Hashes
-from pip._internal.utils.misc import (
-    redact_auth_from_url,
-    split_auth_from_netloc,
-    splitext,
-)
-from pip._internal.utils.models import KeyBasedCompareMixin
-from pip._internal.utils.urls import path_to_url, url_to_path
-
-if TYPE_CHECKING:
-    from pip._internal.index.collector import HTMLPage
-
-logger = logging.getLogger(__name__)
-
-
-_SUPPORTED_HASHES = ("sha1", "sha224", "sha384", "sha256", "sha512", "md5")
-
-
-class Link(KeyBasedCompareMixin):
-    """Represents a parsed link from a Package Index's simple URL"""
-
-    __slots__ = [
-        "_parsed_url",
-        "_url",
-        "comes_from",
-        "requires_python",
-        "yanked_reason",
-        "cache_link_parsing",
-    ]
-
-    def __init__(
-        self,
-        url: str,
-        comes_from: Optional[Union[str, "HTMLPage"]] = None,
-        requires_python: Optional[str] = None,
-        yanked_reason: Optional[str] = None,
-        cache_link_parsing: bool = True,
-    ) -> None:
-        """
-        :param url: url of the resource pointed to (href of the link)
-        :param comes_from: instance of HTMLPage where the link was found,
-            or string.
-        :param requires_python: String containing the `Requires-Python`
-            metadata field, specified in PEP 345. This may be specified by
-            a data-requires-python attribute in the HTML link tag, as
-            described in PEP 503.
-        :param yanked_reason: the reason the file has been yanked, if the
-            file has been yanked, or None if the file hasn't been yanked.
-            This is the value of the "data-yanked" attribute, if present, in
-            a simple repository HTML link. If the file has been yanked but
-            no reason was provided, this should be the empty string. See
-            PEP 592 for more information and the specification.
-        :param cache_link_parsing: A flag that is used elsewhere to determine
-                                   whether resources retrieved from this link
-                                   should be cached. PyPI index urls should
-                                   generally have this set to False, for
-                                   example.
-        """
-
-        # url can be a UNC windows share
-        if url.startswith("\\\\"):
-            url = path_to_url(url)
-
-        self._parsed_url = urllib.parse.urlsplit(url)
-        # Store the url as a private attribute to prevent accidentally
-        # trying to set a new value.
-        self._url = url
-
-        self.comes_from = comes_from
-        self.requires_python = requires_python if requires_python else None
-        self.yanked_reason = yanked_reason
-
-        super().__init__(key=url, defining_class=Link)
-
-        self.cache_link_parsing = cache_link_parsing
-
-    def __str__(self) -> str:
-        if self.requires_python:
-            rp = f" (requires-python:{self.requires_python})"
-        else:
-            rp = ""
-        if self.comes_from:
-            return "{} (from {}){}".format(
-                redact_auth_from_url(self._url), self.comes_from, rp
-            )
-        else:
-            return redact_auth_from_url(str(self._url))
-
-    def __repr__(self) -> str:
-        return f"<Link {self}>"
-
-    @property
-    def url(self) -> str:
-        return self._url
-
-    @property
-    def filename(self) -> str:
-        path = self.path.rstrip("/")
-        name = posixpath.basename(path)
-        if not name:
-            # Make sure we don't leak auth information if the netloc
-            # includes a username and password.
-            netloc, user_pass = split_auth_from_netloc(self.netloc)
-            return netloc
-
-        name = urllib.parse.unquote(name)
-        assert name, f"URL {self._url!r} produced no filename"
-        return name
-
-    @property
-    def file_path(self) -> str:
-        return url_to_path(self.url)
-
-    @property
-    def scheme(self) -> str:
-        return self._parsed_url.scheme
-
-    @property
-    def netloc(self) -> str:
-        """
-        This can contain auth information.
-        """
-        return self._parsed_url.netloc
-
-    @property
-    def path(self) -> str:
-        return urllib.parse.unquote(self._parsed_url.path)
-
-    def splitext(self) -> Tuple[str, str]:
-        return splitext(posixpath.basename(self.path.rstrip("/")))
-
-    @property
-    def ext(self) -> str:
-        return self.splitext()[1]
-
-    @property
-    def url_without_fragment(self) -> str:
-        scheme, netloc, path, query, fragment = self._parsed_url
-        return urllib.parse.urlunsplit((scheme, netloc, path, query, ""))
-
-    _egg_fragment_re = re.compile(r"[#&]egg=([^&]*)")
-
-    @property
-    def egg_fragment(self) -> Optional[str]:
-        match = self._egg_fragment_re.search(self._url)
-        if not match:
-            return None
-        return match.group(1)
-
-    _subdirectory_fragment_re = re.compile(r"[#&]subdirectory=([^&]*)")
-
-    @property
-    def subdirectory_fragment(self) -> Optional[str]:
-        match = self._subdirectory_fragment_re.search(self._url)
-        if not match:
-            return None
-        return match.group(1)
-
-    _hash_re = re.compile(
-        r"({choices})=([a-f0-9]+)".format(choices="|".join(_SUPPORTED_HASHES))
-    )
-
-    @property
-    def hash(self) -> Optional[str]:
-        match = self._hash_re.search(self._url)
-        if match:
-            return match.group(2)
-        return None
-
-    @property
-    def hash_name(self) -> Optional[str]:
-        match = self._hash_re.search(self._url)
-        if match:
-            return match.group(1)
-        return None
-
-    @property
-    def show_url(self) -> str:
-        return posixpath.basename(self._url.split("#", 1)[0].split("?", 1)[0])
-
-    @property
-    def is_file(self) -> bool:
-        return self.scheme == "file"
-
-    def is_existing_dir(self) -> bool:
-        return self.is_file and os.path.isdir(self.file_path)
-
-    @property
-    def is_wheel(self) -> bool:
-        return self.ext == WHEEL_EXTENSION
-
-    @property
-    def is_vcs(self) -> bool:
-        from pip._internal.vcs import vcs
-
-        return self.scheme in vcs.all_schemes
-
-    @property
-    def is_yanked(self) -> bool:
-        return self.yanked_reason is not None
-
-    @property
-    def has_hash(self) -> bool:
-        return self.hash_name is not None
-
-    def is_hash_allowed(self, hashes: Optional[Hashes]) -> bool:
-        """
-        Return True if the link has a hash and it is allowed.
-        """
-        if hashes is None or not self.has_hash:
-            return False
-        # Assert non-None so mypy knows self.hash_name and self.hash are str.
-        assert self.hash_name is not None
-        assert self.hash is not None
-
-        return hashes.is_hash_allowed(self.hash_name, hex_digest=self.hash)
-
-
-class _CleanResult(NamedTuple):
-    """Convert link for equivalency check.
-
-    This is used in the resolver to check whether two URL-specified requirements
-    likely point to the same distribution and can be considered equivalent. This
-    equivalency logic avoids comparing URLs literally, which can be too strict
-    (e.g. "a=1&b=2" vs "b=2&a=1") and produce conflicts unexpecting to users.
-
-    Currently this does three things:
-
-    1. Drop the basic auth part. This is technically wrong since a server can
-       serve different content based on auth, but if it does that, it is even
-       impossible to guarantee two URLs without auth are equivalent, since
-       the user can input different auth information when prompted. So the
-       practical solution is to assume the auth doesn't affect the response.
-    2. Parse the query to avoid the ordering issue. Note that ordering under the
-       same key in the query are NOT cleaned; i.e. "a=1&a=2" and "a=2&a=1" are
-       still considered different.
-    3. Explicitly drop most of the fragment part, except ``subdirectory=`` and
-       hash values, since it should have no impact the downloaded content. Note
-       that this drops the "egg=" part historically used to denote the requested
-       project (and extras), which is wrong in the strictest sense, but too many
-       people are supplying it inconsistently to cause superfluous resolution
-       conflicts, so we choose to also ignore them.
-    """
-
-    parsed: urllib.parse.SplitResult
-    query: Dict[str, List[str]]
-    subdirectory: str
-    hashes: Dict[str, str]
-
-
-def _clean_link(link: Link) -> _CleanResult:
-    parsed = link._parsed_url
-    netloc = parsed.netloc.rsplit("@", 1)[-1]
-    # According to RFC 8089, an empty host in file: means localhost.
-    if parsed.scheme == "file" and not netloc:
-        netloc = "localhost"
-    fragment = urllib.parse.parse_qs(parsed.fragment)
-    if "egg" in fragment:
-        logger.debug("Ignoring egg= fragment in %s", link)
-    try:
-        # If there are multiple subdirectory values, use the first one.
-        # This matches the behavior of Link.subdirectory_fragment.
-        subdirectory = fragment["subdirectory"][0]
-    except (IndexError, KeyError):
-        subdirectory = ""
-    # If there are multiple hash values under the same algorithm, use the
-    # first one. This matches the behavior of Link.hash_value.
-    hashes = {k: fragment[k][0] for k in _SUPPORTED_HASHES if k in fragment}
-    return _CleanResult(
-        parsed=parsed._replace(netloc=netloc, query="", fragment=""),
-        query=urllib.parse.parse_qs(parsed.query),
-        subdirectory=subdirectory,
-        hashes=hashes,
-    )
-
-
-@functools.lru_cache(maxsize=None)
-def links_equivalent(link1: Link, link2: Link) -> bool:
-    return _clean_link(link1) == _clean_link(link2)

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

@@ -1,31 +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.
-"""
-
-
-SCHEME_KEYS = ["platlib", "purelib", "headers", "scripts", "data"]
-
-
-class Scheme:
-    """A Scheme holds paths which are used as the base directories for
-    artifacts associated with a Python package.
-    """
-
-    __slots__ = SCHEME_KEYS
-
-    def __init__(
-        self,
-        platlib: str,
-        purelib: str,
-        headers: str,
-        scripts: str,
-        data: str,
-    ) -> None:
-        self.platlib = platlib
-        self.purelib = purelib
-        self.headers = headers
-        self.scripts = scripts
-        self.data = data