@scrypted/arlo 0.11.26 → 0.11.27

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

package/venv/lib/python3.10/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.10/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.10/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.10/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>[^\s-]+?)-(?P<ver>[^\s-]*?))
-        ((-(?P<build>\d[^-]*?))?-(?P<pyver>[^\s-]+?)-(?P<abi>[^\s-]+?)-(?P<plat>[^\s-]+?)
-        \.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)