android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

venv/Lib/site-packages/pip/_internal/wheel_builder.py

@@ -1,261 +0,0 @@
-"""Orchestrator for building wheels from InstallRequirements."""
-
-from __future__ import annotations
-
-import logging
-import os.path
-import re
-from collections.abc import Iterable
-from tempfile import TemporaryDirectory
-
-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.req.req_install import InstallRequirement
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import ensure_dir, hash_file
-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)
-
-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_cache(
-    req: InstallRequirement,
-) -> bool | None:
-    """
-    Return whether a built InstallRequirement can be stored in the persistent
-    wheel cache, assuming the wheel cache is available.
-    """
-    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 _verify_one(req: InstallRequirement, wheel_path: str) -> None:
-    canonical_name = canonicalize_name(req.name or "")
-    w = Wheel(os.path.basename(wheel_path))
-    if w.name != canonical_name:
-        raise InvalidWheelFilename(
-            f"Wheel has unexpected file name: expected {canonical_name!r}, "
-            f"got {w.name!r}",
-        )
-    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(
-            f"Wheel has unexpected file name: expected {dist_verstr!r}, "
-            f"got {w.version!r}",
-        )
-    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(
-            f"Metadata 1.2 mandates PEP 440 version, but {dist_verstr!r} is not"
-        )
-
-
-def _build_one(
-    req: InstallRequirement,
-    output_dir: str,
-    verify: bool,
-    editable: bool,
-) -> str | None:
-    """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, 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,
-    editable: bool,
-) -> str | None:
-    with TemporaryDirectory(dir=output_dir) as wheel_directory:
-        assert req.name
-        assert req.metadata_directory
-        assert req.pep517_backend
-        if editable:
-            wheel_path = build_wheel_editable(
-                name=req.name,
-                backend=req.pep517_backend,
-                metadata_directory=req.metadata_directory,
-                wheel_directory=wheel_directory,
-            )
-        else:
-            wheel_path = build_wheel_pep517(
-                name=req.name,
-                backend=req.pep517_backend,
-                metadata_directory=req.metadata_directory,
-                wheel_directory=wheel_directory,
-            )
-
-        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)
-                # We can do a replace here because wheel_path is guaranteed to
-                # be in the same filesystem as output_dir. This will perform an
-                # atomic rename, which is necessary to avoid concurrency issues
-                # when populating the cache.
-                os.replace(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,
-                )
-        return None
-
-
-def build(
-    requirements: Iterable[InstallRequirement],
-    wheel_cache: WheelCache,
-    verify: bool,
-) -> 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,
-                req.editable and req.permit_editable_wheels,
-            )
-            if wheel_file:
-                # Record the download origin in the cache
-                if req.download_info is not None:
-                    # download_info is guaranteed to be set because when we build an
-                    # InstallRequirement it has been through the preparer before, but
-                    # let's be cautious.
-                    wheel_cache.record_download_origin(cache_dir, req.download_info)
-                # 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

venv/Lib/site-packages/pip/_vendor/__init__.py

@@ -1,117 +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("dependency-groups")
-    vendored("distlib")
-    vendored("distro")
-    vendored("packaging")
-    vendored("packaging.version")
-    vendored("packaging.specifiers")
-    vendored("pkg_resources")
-    vendored("platformdirs")
-    vendored("progress")
-    vendored("pyproject_hooks")
-    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("rich")
-    vendored("rich.console")
-    vendored("rich.highlighter")
-    vendored("rich.logging")
-    vendored("rich.markup")
-    vendored("rich.progress")
-    vendored("rich.segment")
-    vendored("rich.style")
-    vendored("rich.text")
-    vendored("rich.traceback")
-    if sys.version_info < (3, 11):
-        vendored("tomli")
-    vendored("truststore")
-    vendored("urllib3")

venv/Lib/site-packages/pip/_vendor/cachecontrol/__init__.py

@@ -1,29 +0,0 @@
-# SPDX-FileCopyrightText: 2015 Eric Larson
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""CacheControl import Interface.
-
-Make it easy to import from cachecontrol without long namespaces.
-"""
-
-__author__ = "Eric Larson"
-__email__ = "eric@ionrock.org"
-__version__ = "0.14.3"
-
-from pip._vendor.cachecontrol.adapter import CacheControlAdapter
-from pip._vendor.cachecontrol.controller import CacheController
-from pip._vendor.cachecontrol.wrapper import CacheControl
-
-__all__ = [
-    "__author__",
-    "__email__",
-    "__version__",
-    "CacheControlAdapter",
-    "CacheController",
-    "CacheControl",
-]
-
-import logging
-
-logging.getLogger(__name__).addHandler(logging.NullHandler())

venv/Lib/site-packages/pip/_vendor/cachecontrol/_cmd.py

@@ -1,70 +0,0 @@
-# SPDX-FileCopyrightText: 2015 Eric Larson
-#
-# SPDX-License-Identifier: Apache-2.0
-from __future__ import annotations
-
-import logging
-from argparse import ArgumentParser
-from typing import TYPE_CHECKING
-
-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
-
-if TYPE_CHECKING:
-    from argparse import Namespace
-
-    from pip._vendor.cachecontrol.controller import CacheController
-
-
-def setup_logging() -> None:
-    logger.setLevel(logging.DEBUG)
-    handler = logging.StreamHandler()
-    logger.addHandler(handler)
-
-
-def get_session() -> requests.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  # type: ignore[attr-defined]
-    return sess
-
-
-def get_args() -> Namespace:
-    parser = ArgumentParser()
-    parser.add_argument("url", help="The URL to try and cache")
-    return parser.parse_args()
-
-
-def main() -> 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
-    cache_controller: CacheController = (
-        sess.cache_controller  # type: ignore[attr-defined]
-    )
-    cache_controller.cache_response(resp.request, resp.raw)
-
-    # Now try to get it
-    if cache_controller.cached_request(resp.request):
-        print("Cached!")
-    else:
-        print("Not cached :(")
-
-
-if __name__ == "__main__":
-    main()

venv/Lib/site-packages/pip/_vendor/cachecontrol/adapter.py

@@ -1,168 +0,0 @@
-# SPDX-FileCopyrightText: 2015 Eric Larson
-#
-# SPDX-License-Identifier: Apache-2.0
-from __future__ import annotations
-
-import functools
-import types
-import weakref
-import zlib
-from typing import TYPE_CHECKING, Any, Collection, Mapping
-
-from pip._vendor.requests.adapters import HTTPAdapter
-
-from pip._vendor.cachecontrol.cache import DictCache
-from pip._vendor.cachecontrol.controller import PERMANENT_REDIRECT_STATUSES, CacheController
-from pip._vendor.cachecontrol.filewrapper import CallbackFileWrapper
-
-if TYPE_CHECKING:
-    from pip._vendor.requests import PreparedRequest, Response
-    from pip._vendor.urllib3 import HTTPResponse
-
-    from pip._vendor.cachecontrol.cache import BaseCache
-    from pip._vendor.cachecontrol.heuristics import BaseHeuristic
-    from pip._vendor.cachecontrol.serialize import Serializer
-
-
-class CacheControlAdapter(HTTPAdapter):
-    invalidating_methods = {"PUT", "PATCH", "DELETE"}
-
-    def __init__(
-        self,
-        cache: BaseCache | None = None,
-        cache_etags: bool = True,
-        controller_class: type[CacheController] | None = None,
-        serializer: Serializer | None = None,
-        heuristic: BaseHeuristic | None = None,
-        cacheable_methods: Collection[str] | None = None,
-        *args: Any,
-        **kw: Any,
-    ) -> None:
-        super().__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: PreparedRequest,
-        stream: bool = False,
-        timeout: None | float | tuple[float, float] | tuple[float, None] = None,
-        verify: bool | str = True,
-        cert: (None | bytes | str | tuple[bytes | str, bytes | str]) = None,
-        proxies: Mapping[str, str] | None = None,
-        cacheable_methods: Collection[str] | None = None,
-    ) -> Response:
-        """
-        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().send(request, stream, timeout, verify, cert, proxies)
-
-        return resp
-
-    def build_response(  # type: ignore[override]
-        self,
-        request: PreparedRequest,
-        response: HTTPResponse,
-        from_cache: bool = False,
-        cacheable_methods: Collection[str] | None = None,
-    ) -> Response:
-        """
-        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 int(response.status) in PERMANENT_REDIRECT_STATUSES:
-                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(  # type: ignore[assignment]
-                    response._fp,  # type: ignore[arg-type]
-                    functools.partial(
-                        self.controller.cache_response, request, weakref.ref(response)
-                    ),
-                )
-                if response.chunked:
-                    super_update_chunk_length = response.__class__._update_chunk_length
-
-                    def _update_chunk_length(
-                        weak_self: weakref.ReferenceType[HTTPResponse],
-                    ) -> None:
-                        self = weak_self()
-                        if self is None:
-                            return
-
-                        super_update_chunk_length(self)
-                        if self.chunk_left == 0:
-                            self._fp._close()  # type: ignore[union-attr]
-
-                    response._update_chunk_length = functools.partial(  # type: ignore[method-assign]
-                        _update_chunk_length, weakref.ref(response)
-                    )
-
-        resp: Response = super().build_response(request, response)
-
-        # See if we should invalidate the cache.
-        if request.method in self.invalidating_methods and resp.ok:
-            assert request.url is not None
-            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  # type: ignore[attr-defined]
-
-        return resp
-
-    def close(self) -> None:
-        self.cache.close()
-        super().close()  # type: ignore[no-untyped-call]