@scrypted/server 0.0.141 → 0.0.142

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

@@ -1,129 +0,0 @@
-import itertools
-import logging
-import os
-import posixpath
-import urllib.parse
-from typing import List
-
-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__)
-
-
-class SearchScope:
-
-    """
-    Encapsulates the locations that pip is configured to search.
-    """
-
-    __slots__ = ["find_links", "index_urls"]
-
-    @classmethod
-    def create(
-        cls,
-        find_links: List[str],
-        index_urls: List[str],
-    ) -> "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,
-        )
-
-    def __init__(
-        self,
-        find_links: List[str],
-        index_urls: List[str],
-    ) -> None:
-        self.find_links = find_links
-        self.index_urls = index_urls
-
-    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]

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

@@ -1,51 +0,0 @@
-from typing import Optional
-
-from pip._internal.models.format_control import FormatControl
-
-
-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: Optional[FormatControl] = None,
-        prefer_binary: bool = False,
-        ignore_requires_python: Optional[bool] = 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

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

@@ -1,110 +0,0 @@
-import sys
-from typing import List, Optional, Tuple
-
-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",
-    ]
-
-    def __init__(
-        self,
-        platforms: Optional[List[str]] = None,
-        py_version_info: Optional[Tuple[int, ...]] = None,
-        abis: Optional[List[str]] = None,
-        implementation: Optional[str] = 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_tags().
-        self._valid_tags: Optional[List[Tag]] = 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_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

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

@@ -1,89 +0,0 @@
-"""Represents a wheel file and provides access to the various parts of the
-name that have meaning.
-"""
-import re
-from typing import Dict, Iterable, List
-
-from pip._vendor.packaging.tags import Tag
-
-from pip._internal.exceptions import InvalidWheelFilename
-
-
-class Wheel:
-    """A wheel file"""
-
-    wheel_file_re = re.compile(
-        r"""^(?P<namever>(?P<name>.+?)-(?P<ver>.*?))
-        ((-(?P<build>\d[^-]*?))?-(?P<pyver>.+?)-(?P<abi>.+?)-(?P<plat>.+?)
-        \.whl|\.dist-info)$""",
-        re.VERBOSE,
-    )
-
-    def __init__(self, filename: str) -> None:
-        """
-        :raises InvalidWheelFilename: when the filename is invalid for a wheel
-        """
-        wheel_info = self.wheel_file_re.match(filename)
-        if not wheel_info:
-            raise InvalidWheelFilename(f"{filename} is not a valid wheel filename.")
-        self.filename = filename
-        self.name = wheel_info.group("name").replace("_", "-")
-        # we'll assume "_" means "-" due to wheel naming scheme
-        # (https://github.com/pypa/pip/issues/1150)
-        self.version = wheel_info.group("ver").replace("_", "-")
-        self.build_tag = wheel_info.group("build")
-        self.pyversions = wheel_info.group("pyver").split(".")
-        self.abis = wheel_info.group("abi").split(".")
-        self.plats = wheel_info.group("plat").split(".")
-
-        # All the tag combinations from this file
-        self.file_tags = {
-            Tag(x, y, z) for x in self.pyversions for y in self.abis for z in self.plats
-        }
-
-    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.
-        """
-        return min(tags.index(tag) for tag in self.file_tags if tag in tags)
-
-    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)

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

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