@scrypted/server 0.0.141 → 0.0.142

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

@@ -1,375 +0,0 @@
-"""Orchestrator for building wheels from InstallRequirements.
-"""
-
-import logging
-import os.path
-import re
-import shutil
-from typing import Any, Callable, Iterable, List, Optional, Tuple
-
-from pip._vendor.packaging.utils import canonicalize_name, canonicalize_version
-from pip._vendor.packaging.version import InvalidVersion, Version
-
-from pip._internal.cache import WheelCache
-from pip._internal.exceptions import InvalidWheelFilename, UnsupportedWheel
-from pip._internal.metadata import FilesystemWheel, get_wheel_distribution
-from pip._internal.models.link import Link
-from pip._internal.models.wheel import Wheel
-from pip._internal.operations.build.wheel import build_wheel_pep517
-from pip._internal.operations.build.wheel_editable import build_wheel_editable
-from pip._internal.operations.build.wheel_legacy import build_wheel_legacy
-from pip._internal.req.req_install import InstallRequirement
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import ensure_dir, hash_file, is_wheel_installed
-from pip._internal.utils.setuptools_build import make_setuptools_clean_args
-from pip._internal.utils.subprocess import call_subprocess
-from pip._internal.utils.temp_dir import TempDirectory
-from pip._internal.utils.urls import path_to_url
-from pip._internal.vcs import vcs
-
-logger = logging.getLogger(__name__)
-
-_egg_info_re = re.compile(r"([a-z0-9_.]+)-([a-z0-9_.!+-]+)", re.IGNORECASE)
-
-BinaryAllowedPredicate = Callable[[InstallRequirement], bool]
-BuildResult = Tuple[List[InstallRequirement], List[InstallRequirement]]
-
-
-def _contains_egg_info(s: str) -> bool:
-    """Determine whether the string looks like an egg_info.
-
-    :param s: The string to parse. E.g. foo-2.1
-    """
-    return bool(_egg_info_re.search(s))
-
-
-def _should_build(
-    req: InstallRequirement,
-    need_wheel: bool,
-    check_binary_allowed: BinaryAllowedPredicate,
-) -> bool:
-    """Return whether an InstallRequirement should be built into a wheel."""
-    if req.constraint:
-        # never build requirements that are merely constraints
-        return False
-    if req.is_wheel:
-        if need_wheel:
-            logger.info(
-                "Skipping %s, due to already being wheel.",
-                req.name,
-            )
-        return False
-
-    if need_wheel:
-        # i.e. pip wheel, not pip install
-        return True
-
-    # From this point, this concerns the pip install command only
-    # (need_wheel=False).
-
-    if not req.source_dir:
-        return False
-
-    if req.editable:
-        # we only build PEP 660 editable requirements
-        return req.supports_pyproject_editable()
-
-    if req.use_pep517:
-        return True
-
-    if not check_binary_allowed(req):
-        logger.info(
-            "Skipping wheel build for %s, due to binaries being disabled for it.",
-            req.name,
-        )
-        return False
-
-    if not is_wheel_installed():
-        # we don't build legacy requirements if wheel is not installed
-        logger.info(
-            "Using legacy 'setup.py install' for %s, "
-            "since package 'wheel' is not installed.",
-            req.name,
-        )
-        return False
-
-    return True
-
-
-def should_build_for_wheel_command(
-    req: InstallRequirement,
-) -> bool:
-    return _should_build(req, need_wheel=True, check_binary_allowed=_always_true)
-
-
-def should_build_for_install_command(
-    req: InstallRequirement,
-    check_binary_allowed: BinaryAllowedPredicate,
-) -> bool:
-    return _should_build(
-        req, need_wheel=False, check_binary_allowed=check_binary_allowed
-    )
-
-
-def _should_cache(
-    req: InstallRequirement,
-) -> Optional[bool]:
-    """
-    Return whether a built InstallRequirement can be stored in the persistent
-    wheel cache, assuming the wheel cache is available, and _should_build()
-    has determined a wheel needs to be built.
-    """
-    if req.editable or not req.source_dir:
-        # never cache editable requirements
-        return False
-
-    if req.link and req.link.is_vcs:
-        # VCS checkout. Do not cache
-        # unless it points to an immutable commit hash.
-        assert not req.editable
-        assert req.source_dir
-        vcs_backend = vcs.get_backend_for_scheme(req.link.scheme)
-        assert vcs_backend
-        if vcs_backend.is_immutable_rev_checkout(req.link.url, req.source_dir):
-            return True
-        return False
-
-    assert req.link
-    base, ext = req.link.splitext()
-    if _contains_egg_info(base):
-        return True
-
-    # Otherwise, do not cache.
-    return False
-
-
-def _get_cache_dir(
-    req: InstallRequirement,
-    wheel_cache: WheelCache,
-) -> str:
-    """Return the persistent or temporary cache directory where the built
-    wheel need to be stored.
-    """
-    cache_available = bool(wheel_cache.cache_dir)
-    assert req.link
-    if cache_available and _should_cache(req):
-        cache_dir = wheel_cache.get_path_for_link(req.link)
-    else:
-        cache_dir = wheel_cache.get_ephem_path_for_link(req.link)
-    return cache_dir
-
-
-def _always_true(_: Any) -> bool:
-    return True
-
-
-def _verify_one(req: InstallRequirement, wheel_path: str) -> None:
-    canonical_name = canonicalize_name(req.name or "")
-    w = Wheel(os.path.basename(wheel_path))
-    if canonicalize_name(w.name) != canonical_name:
-        raise InvalidWheelFilename(
-            "Wheel has unexpected file name: expected {!r}, "
-            "got {!r}".format(canonical_name, w.name),
-        )
-    dist = get_wheel_distribution(FilesystemWheel(wheel_path), canonical_name)
-    dist_verstr = str(dist.version)
-    if canonicalize_version(dist_verstr) != canonicalize_version(w.version):
-        raise InvalidWheelFilename(
-            "Wheel has unexpected file name: expected {!r}, "
-            "got {!r}".format(dist_verstr, w.version),
-        )
-    metadata_version_value = dist.metadata_version
-    if metadata_version_value is None:
-        raise UnsupportedWheel("Missing Metadata-Version")
-    try:
-        metadata_version = Version(metadata_version_value)
-    except InvalidVersion:
-        msg = f"Invalid Metadata-Version: {metadata_version_value}"
-        raise UnsupportedWheel(msg)
-    if metadata_version >= Version("1.2") and not isinstance(dist.version, Version):
-        raise UnsupportedWheel(
-            "Metadata 1.2 mandates PEP 440 version, "
-            "but {!r} is not".format(dist_verstr)
-        )
-
-
-def _build_one(
-    req: InstallRequirement,
-    output_dir: str,
-    verify: bool,
-    build_options: List[str],
-    global_options: List[str],
-    editable: bool,
-) -> Optional[str]:
-    """Build one wheel.
-
-    :return: The filename of the built wheel, or None if the build failed.
-    """
-    artifact = "editable" if editable else "wheel"
-    try:
-        ensure_dir(output_dir)
-    except OSError as e:
-        logger.warning(
-            "Building %s for %s failed: %s",
-            artifact,
-            req.name,
-            e,
-        )
-        return None
-
-    # Install build deps into temporary directory (PEP 518)
-    with req.build_env:
-        wheel_path = _build_one_inside_env(
-            req, output_dir, build_options, global_options, editable
-        )
-    if wheel_path and verify:
-        try:
-            _verify_one(req, wheel_path)
-        except (InvalidWheelFilename, UnsupportedWheel) as e:
-            logger.warning("Built %s for %s is invalid: %s", artifact, req.name, e)
-            return None
-    return wheel_path
-
-
-def _build_one_inside_env(
-    req: InstallRequirement,
-    output_dir: str,
-    build_options: List[str],
-    global_options: List[str],
-    editable: bool,
-) -> Optional[str]:
-    with TempDirectory(kind="wheel") as temp_dir:
-        assert req.name
-        if req.use_pep517:
-            assert req.metadata_directory
-            assert req.pep517_backend
-            if global_options:
-                logger.warning(
-                    "Ignoring --global-option when building %s using PEP 517", req.name
-                )
-            if build_options:
-                logger.warning(
-                    "Ignoring --build-option when building %s using PEP 517", req.name
-                )
-            if editable:
-                wheel_path = build_wheel_editable(
-                    name=req.name,
-                    backend=req.pep517_backend,
-                    metadata_directory=req.metadata_directory,
-                    tempd=temp_dir.path,
-                )
-            else:
-                wheel_path = build_wheel_pep517(
-                    name=req.name,
-                    backend=req.pep517_backend,
-                    metadata_directory=req.metadata_directory,
-                    tempd=temp_dir.path,
-                )
-        else:
-            wheel_path = build_wheel_legacy(
-                name=req.name,
-                setup_py_path=req.setup_py_path,
-                source_dir=req.unpacked_source_directory,
-                global_options=global_options,
-                build_options=build_options,
-                tempd=temp_dir.path,
-            )
-
-        if wheel_path is not None:
-            wheel_name = os.path.basename(wheel_path)
-            dest_path = os.path.join(output_dir, wheel_name)
-            try:
-                wheel_hash, length = hash_file(wheel_path)
-                shutil.move(wheel_path, dest_path)
-                logger.info(
-                    "Created wheel for %s: filename=%s size=%d sha256=%s",
-                    req.name,
-                    wheel_name,
-                    length,
-                    wheel_hash.hexdigest(),
-                )
-                logger.info("Stored in directory: %s", output_dir)
-                return dest_path
-            except Exception as e:
-                logger.warning(
-                    "Building wheel for %s failed: %s",
-                    req.name,
-                    e,
-                )
-        # Ignore return, we can't do anything else useful.
-        if not req.use_pep517:
-            _clean_one_legacy(req, global_options)
-        return None
-
-
-def _clean_one_legacy(req: InstallRequirement, global_options: List[str]) -> bool:
-    clean_args = make_setuptools_clean_args(
-        req.setup_py_path,
-        global_options=global_options,
-    )
-
-    logger.info("Running setup.py clean for %s", req.name)
-    try:
-        call_subprocess(clean_args, cwd=req.source_dir)
-        return True
-    except Exception:
-        logger.error("Failed cleaning build dir for %s", req.name)
-        return False
-
-
-def build(
-    requirements: Iterable[InstallRequirement],
-    wheel_cache: WheelCache,
-    verify: bool,
-    build_options: List[str],
-    global_options: List[str],
-) -> BuildResult:
-    """Build wheels.
-
-    :return: The list of InstallRequirement that succeeded to build and
-        the list of InstallRequirement that failed to build.
-    """
-    if not requirements:
-        return [], []
-
-    # Build the wheels.
-    logger.info(
-        "Building wheels for collected packages: %s",
-        ", ".join(req.name for req in requirements),  # type: ignore
-    )
-
-    with indent_log():
-        build_successes, build_failures = [], []
-        for req in requirements:
-            assert req.name
-            cache_dir = _get_cache_dir(req, wheel_cache)
-            wheel_file = _build_one(
-                req,
-                cache_dir,
-                verify,
-                build_options,
-                global_options,
-                req.editable and req.permit_editable_wheels,
-            )
-            if wheel_file:
-                # Update the link for this.
-                req.link = Link(path_to_url(wheel_file))
-                req.local_file_path = req.link.file_path
-                assert req.link.is_wheel
-                build_successes.append(req)
-            else:
-                build_failures.append(req)
-
-    # notify success/failure
-    if build_successes:
-        logger.info(
-            "Successfully built %s",
-            " ".join([req.name for req in build_successes]),  # type: ignore
-        )
-    if build_failures:
-        logger.info(
-            "Failed to build %s",
-            " ".join([req.name for req in build_failures]),  # type: ignore
-        )
-    # Return a list of requirements that failed to build
-    return build_successes, build_failures

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

@@ -1,111 +0,0 @@
-"""
-pip._vendor is for vendoring dependencies of pip to prevent needing pip to
-depend on something external.
-
-Files inside of pip._vendor should be considered immutable and should only be
-updated to versions from upstream.
-"""
-from __future__ import absolute_import
-
-import glob
-import os.path
-import sys
-
-# Downstream redistributors which have debundled our dependencies should also
-# patch this value to be true. This will trigger the additional patching
-# to cause things like "six" to be available as pip.
-DEBUNDLED = False
-
-# By default, look in this directory for a bunch of .whl files which we will
-# add to the beginning of sys.path before attempting to import anything. This
-# is done to support downstream re-distributors like Debian and Fedora who
-# wish to create their own Wheels for our dependencies to aid in debundling.
-WHEEL_DIR = os.path.abspath(os.path.dirname(__file__))
-
-
-# Define a small helper function to alias our vendored modules to the real ones
-# if the vendored ones do not exist. This idea of this was taken from
-# https://github.com/kennethreitz/requests/pull/2567.
-def vendored(modulename):
-    vendored_name = "{0}.{1}".format(__name__, modulename)
-
-    try:
-        __import__(modulename, globals(), locals(), level=0)
-    except ImportError:
-        # We can just silently allow import failures to pass here. If we
-        # got to this point it means that ``import pip._vendor.whatever``
-        # failed and so did ``import whatever``. Since we're importing this
-        # upfront in an attempt to alias imports, not erroring here will
-        # just mean we get a regular import error whenever pip *actually*
-        # tries to import one of these modules to use it, which actually
-        # gives us a better error message than we would have otherwise
-        # gotten.
-        pass
-    else:
-        sys.modules[vendored_name] = sys.modules[modulename]
-        base, head = vendored_name.rsplit(".", 1)
-        setattr(sys.modules[base], head, sys.modules[modulename])
-
-
-# If we're operating in a debundled setup, then we want to go ahead and trigger
-# the aliasing of our vendored libraries as well as looking for wheels to add
-# to our sys.path. This will cause all of this code to be a no-op typically
-# however downstream redistributors can enable it in a consistent way across
-# all platforms.
-if DEBUNDLED:
-    # Actually look inside of WHEEL_DIR to find .whl files and add them to the
-    # front of our sys.path.
-    sys.path[:] = glob.glob(os.path.join(WHEEL_DIR, "*.whl")) + sys.path
-
-    # Actually alias all of our vendored dependencies.
-    vendored("cachecontrol")
-    vendored("certifi")
-    vendored("colorama")
-    vendored("distlib")
-    vendored("distro")
-    vendored("html5lib")
-    vendored("six")
-    vendored("six.moves")
-    vendored("six.moves.urllib")
-    vendored("six.moves.urllib.parse")
-    vendored("packaging")
-    vendored("packaging.version")
-    vendored("packaging.specifiers")
-    vendored("pep517")
-    vendored("pkg_resources")
-    vendored("platformdirs")
-    vendored("progress")
-    vendored("requests")
-    vendored("requests.exceptions")
-    vendored("requests.packages")
-    vendored("requests.packages.urllib3")
-    vendored("requests.packages.urllib3._collections")
-    vendored("requests.packages.urllib3.connection")
-    vendored("requests.packages.urllib3.connectionpool")
-    vendored("requests.packages.urllib3.contrib")
-    vendored("requests.packages.urllib3.contrib.ntlmpool")
-    vendored("requests.packages.urllib3.contrib.pyopenssl")
-    vendored("requests.packages.urllib3.exceptions")
-    vendored("requests.packages.urllib3.fields")
-    vendored("requests.packages.urllib3.filepost")
-    vendored("requests.packages.urllib3.packages")
-    vendored("requests.packages.urllib3.packages.ordered_dict")
-    vendored("requests.packages.urllib3.packages.six")
-    vendored("requests.packages.urllib3.packages.ssl_match_hostname")
-    vendored("requests.packages.urllib3.packages.ssl_match_hostname."
-             "_implementation")
-    vendored("requests.packages.urllib3.poolmanager")
-    vendored("requests.packages.urllib3.request")
-    vendored("requests.packages.urllib3.response")
-    vendored("requests.packages.urllib3.util")
-    vendored("requests.packages.urllib3.util.connection")
-    vendored("requests.packages.urllib3.util.request")
-    vendored("requests.packages.urllib3.util.response")
-    vendored("requests.packages.urllib3.util.retry")
-    vendored("requests.packages.urllib3.util.ssl_")
-    vendored("requests.packages.urllib3.util.timeout")
-    vendored("requests.packages.urllib3.util.url")
-    vendored("resolvelib")
-    vendored("tenacity")
-    vendored("tomli")
-    vendored("urllib3")

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/__init__.py

@@ -1,11 +0,0 @@
-"""CacheControl import Interface.
-
-Make it easy to import from cachecontrol without long namespaces.
-"""
-__author__ = "Eric Larson"
-__email__ = "eric@ionrock.org"
-__version__ = "0.12.6"
-
-from .wrapper import CacheControl
-from .adapter import CacheControlAdapter
-from .controller import CacheController

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/_cmd.py

@@ -1,57 +0,0 @@
-import logging
-
-from pip._vendor import requests
-
-from pip._vendor.cachecontrol.adapter import CacheControlAdapter
-from pip._vendor.cachecontrol.cache import DictCache
-from pip._vendor.cachecontrol.controller import logger
-
-from argparse import ArgumentParser
-
-
-def setup_logging():
-    logger.setLevel(logging.DEBUG)
-    handler = logging.StreamHandler()
-    logger.addHandler(handler)
-
-
-def get_session():
-    adapter = CacheControlAdapter(
-        DictCache(), cache_etags=True, serializer=None, heuristic=None
-    )
-    sess = requests.Session()
-    sess.mount("http://", adapter)
-    sess.mount("https://", adapter)
-
-    sess.cache_controller = adapter.controller
-    return sess
-
-
-def get_args():
-    parser = ArgumentParser()
-    parser.add_argument("url", help="The URL to try and cache")
-    return parser.parse_args()
-
-
-def main(args=None):
-    args = get_args()
-    sess = get_session()
-
-    # Make a request to get a response
-    resp = sess.get(args.url)
-
-    # Turn on logging
-    setup_logging()
-
-    # try setting the cache
-    sess.cache_controller.cache_response(resp.request, resp.raw)
-
-    # Now try to get it
-    if sess.cache_controller.cached_request(resp.request):
-        print("Cached!")
-    else:
-        print("Not cached :(")
-
-
-if __name__ == "__main__":
-    main()

package/.venv/lib/python3.9/site-packages/pip/_vendor/cachecontrol/adapter.py

@@ -1,133 +0,0 @@
-import types
-import functools
-import zlib
-
-from pip._vendor.requests.adapters import HTTPAdapter
-
-from .controller import CacheController
-from .cache import DictCache
-from .filewrapper import CallbackFileWrapper
-
-
-class CacheControlAdapter(HTTPAdapter):
-    invalidating_methods = {"PUT", "DELETE"}
-
-    def __init__(
-        self,
-        cache=None,
-        cache_etags=True,
-        controller_class=None,
-        serializer=None,
-        heuristic=None,
-        cacheable_methods=None,
-        *args,
-        **kw
-    ):
-        super(CacheControlAdapter, self).__init__(*args, **kw)
-        self.cache = DictCache() if cache is None else cache
-        self.heuristic = heuristic
-        self.cacheable_methods = cacheable_methods or ("GET",)
-
-        controller_factory = controller_class or CacheController
-        self.controller = controller_factory(
-            self.cache, cache_etags=cache_etags, serializer=serializer
-        )
-
-    def send(self, request, cacheable_methods=None, **kw):
-        """
-        Send a request. Use the request information to see if it
-        exists in the cache and cache the response if we need to and can.
-        """
-        cacheable = cacheable_methods or self.cacheable_methods
-        if request.method in cacheable:
-            try:
-                cached_response = self.controller.cached_request(request)
-            except zlib.error:
-                cached_response = None
-            if cached_response:
-                return self.build_response(request, cached_response, from_cache=True)
-
-            # check for etags and add headers if appropriate
-            request.headers.update(self.controller.conditional_headers(request))
-
-        resp = super(CacheControlAdapter, self).send(request, **kw)
-
-        return resp
-
-    def build_response(
-        self, request, response, from_cache=False, cacheable_methods=None
-    ):
-        """
-        Build a response by making a request or using the cache.
-
-        This will end up calling send and returning a potentially
-        cached response
-        """
-        cacheable = cacheable_methods or self.cacheable_methods
-        if not from_cache and request.method in cacheable:
-            # Check for any heuristics that might update headers
-            # before trying to cache.
-            if self.heuristic:
-                response = self.heuristic.apply(response)
-
-            # apply any expiration heuristics
-            if response.status == 304:
-                # We must have sent an ETag request. This could mean
-                # that we've been expired already or that we simply
-                # have an etag. In either case, we want to try and
-                # update the cache if that is the case.
-                cached_response = self.controller.update_cached_response(
-                    request, response
-                )
-
-                if cached_response is not response:
-                    from_cache = True
-
-                # We are done with the server response, read a
-                # possible response body (compliant servers will
-                # not return one, but we cannot be 100% sure) and
-                # release the connection back to the pool.
-                response.read(decode_content=False)
-                response.release_conn()
-
-                response = cached_response
-
-            # We always cache the 301 responses
-            elif response.status == 301:
-                self.controller.cache_response(request, response)
-            else:
-                # Wrap the response file with a wrapper that will cache the
-                #   response when the stream has been consumed.
-                response._fp = CallbackFileWrapper(
-                    response._fp,
-                    functools.partial(
-                        self.controller.cache_response, request, response
-                    ),
-                )
-                if response.chunked:
-                    super_update_chunk_length = response._update_chunk_length
-
-                    def _update_chunk_length(self):
-                        super_update_chunk_length()
-                        if self.chunk_left == 0:
-                            self._fp._close()
-
-                    response._update_chunk_length = types.MethodType(
-                        _update_chunk_length, response
-                    )
-
-        resp = super(CacheControlAdapter, self).build_response(request, response)
-
-        # See if we should invalidate the cache.
-        if request.method in self.invalidating_methods and resp.ok:
-            cache_url = self.controller.cache_url(request.url)
-            self.cache.delete(cache_url)
-
-        # Give the request a from_cache attr to let people use it
-        resp.from_cache = from_cache
-
-        return resp
-
-    def close(self):
-        self.cache.close()
-        super(CacheControlAdapter, self).close()