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

venv/Lib/site-packages/pip/_internal/commands/search.py

@@ -1,178 +0,0 @@
-from __future__ import annotations
-
-import logging
-import shutil
-import sys
-import textwrap
-import xmlrpc.client
-from collections import OrderedDict
-from optparse import Values
-from typing import TypedDict
-
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.req_command import SessionCommandMixin
-from pip._internal.cli.status_codes import NO_MATCHES_FOUND, SUCCESS
-from pip._internal.exceptions import CommandError
-from pip._internal.metadata import get_default_environment
-from pip._internal.metadata.base import BaseDistribution
-from pip._internal.models.index import PyPI
-from pip._internal.network.xmlrpc import PipXmlrpcTransport
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import write_output
-
-
-class TransformedHit(TypedDict):
-    name: str
-    summary: str
-    versions: list[str]
-
-
-logger = logging.getLogger(__name__)
-
-
-class SearchCommand(Command, SessionCommandMixin):
-    """Search for PyPI packages whose name or summary contains <query>."""
-
-    usage = """
-      %prog [options] <query>"""
-    ignore_require_venv = True
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "-i",
-            "--index",
-            dest="index",
-            metavar="URL",
-            default=PyPI.pypi_url,
-            help="Base URL of Python Package Index (default %default)",
-        )
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: list[str]) -> int:
-        if not args:
-            raise CommandError("Missing required argument (search query).")
-        query = args
-        pypi_hits = self.search(query, options)
-        hits = transform_hits(pypi_hits)
-
-        terminal_width = None
-        if sys.stdout.isatty():
-            terminal_width = shutil.get_terminal_size()[0]
-
-        print_results(hits, terminal_width=terminal_width)
-        if pypi_hits:
-            return SUCCESS
-        return NO_MATCHES_FOUND
-
-    def search(self, query: list[str], options: Values) -> list[dict[str, str]]:
-        index_url = options.index
-
-        session = self.get_default_session(options)
-
-        transport = PipXmlrpcTransport(index_url, session)
-        pypi = xmlrpc.client.ServerProxy(index_url, transport)
-        try:
-            hits = pypi.search({"name": query, "summary": query}, "or")
-        except xmlrpc.client.Fault as fault:
-            message = (
-                f"XMLRPC request failed [code: {fault.faultCode}]\n{fault.faultString}"
-            )
-            raise CommandError(message)
-        assert isinstance(hits, list)
-        return hits
-
-
-def transform_hits(hits: list[dict[str, str]]) -> list[TransformedHit]:
-    """
-    The list from pypi is really a list of versions. We want a list of
-    packages with the list of versions stored inline. This converts the
-    list from pypi into one we can use.
-    """
-    packages: dict[str, TransformedHit] = OrderedDict()
-    for hit in hits:
-        name = hit["name"]
-        summary = hit["summary"]
-        version = hit["version"]
-
-        if name not in packages.keys():
-            packages[name] = {
-                "name": name,
-                "summary": summary,
-                "versions": [version],
-            }
-        else:
-            packages[name]["versions"].append(version)
-
-            # if this is the highest version, replace summary and score
-            if version == highest_version(packages[name]["versions"]):
-                packages[name]["summary"] = summary
-
-    return list(packages.values())
-
-
-def print_dist_installation_info(latest: str, dist: BaseDistribution | None) -> None:
-    if dist is not None:
-        with indent_log():
-            if dist.version == latest:
-                write_output("INSTALLED: %s (latest)", dist.version)
-            else:
-                write_output("INSTALLED: %s", dist.version)
-                if parse_version(latest).pre:
-                    write_output(
-                        "LATEST:    %s (pre-release; install"
-                        " with `pip install --pre`)",
-                        latest,
-                    )
-                else:
-                    write_output("LATEST:    %s", latest)
-
-
-def get_installed_distribution(name: str) -> BaseDistribution | None:
-    env = get_default_environment()
-    return env.get_distribution(name)
-
-
-def print_results(
-    hits: list[TransformedHit],
-    name_column_width: int | None = None,
-    terminal_width: int | None = None,
-) -> None:
-    if not hits:
-        return
-    if name_column_width is None:
-        name_column_width = (
-            max(
-                [
-                    len(hit["name"]) + len(highest_version(hit.get("versions", ["-"])))
-                    for hit in hits
-                ]
-            )
-            + 4
-        )
-
-    for hit in hits:
-        name = hit["name"]
-        summary = hit["summary"] or ""
-        latest = highest_version(hit.get("versions", ["-"]))
-        if terminal_width is not None:
-            target_width = terminal_width - name_column_width - 5
-            if target_width > 10:
-                # wrap and indent summary to fit terminal
-                summary_lines = textwrap.wrap(summary, target_width)
-                summary = ("\n" + " " * (name_column_width + 3)).join(summary_lines)
-
-        name_latest = f"{name} ({latest})"
-        line = f"{name_latest:{name_column_width}} - {summary}"
-        try:
-            write_output(line)
-            dist = get_installed_distribution(name)
-            print_dist_installation_info(latest, dist)
-        except UnicodeEncodeError:
-            pass
-
-
-def highest_version(versions: list[str]) -> str:
-    return max(versions, key=parse_version)

venv/Lib/site-packages/pip/_internal/commands/show.py

@@ -1,231 +0,0 @@
-from __future__ import annotations
-
-import logging
-import string
-from collections.abc import Generator, Iterable, Iterator
-from optparse import Values
-from typing import NamedTuple
-
-from pip._vendor.packaging.requirements import InvalidRequirement
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.metadata import BaseDistribution, get_default_environment
-from pip._internal.utils.misc import write_output
-
-logger = logging.getLogger(__name__)
-
-
-def normalize_project_url_label(label: str) -> str:
-    # This logic is from PEP 753 (Well-known Project URLs in Metadata).
-    chars_to_remove = string.punctuation + string.whitespace
-    removal_map = str.maketrans("", "", chars_to_remove)
-    return label.translate(removal_map).lower()
-
-
-class ShowCommand(Command):
-    """
-    Show information about one or more installed packages.
-
-    The output is in RFC-compliant mail header format.
-    """
-
-    usage = """
-      %prog [options] <package> ..."""
-    ignore_require_venv = True
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "-f",
-            "--files",
-            dest="files",
-            action="store_true",
-            default=False,
-            help="Show the full list of installed files for each package.",
-        )
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: list[str]) -> int:
-        if not args:
-            logger.warning("ERROR: Please provide a package name or names.")
-            return ERROR
-        query = args
-
-        results = search_packages_info(query)
-        if not print_results(
-            results, list_files=options.files, verbose=options.verbose
-        ):
-            return ERROR
-        return SUCCESS
-
-
-class _PackageInfo(NamedTuple):
-    name: str
-    version: str
-    location: str
-    editable_project_location: str | None
-    requires: list[str]
-    required_by: list[str]
-    installer: str
-    metadata_version: str
-    classifiers: list[str]
-    summary: str
-    homepage: str
-    project_urls: list[str]
-    author: str
-    author_email: str
-    license: str
-    license_expression: str
-    entry_points: list[str]
-    files: list[str] | None
-
-
-def search_packages_info(query: list[str]) -> Generator[_PackageInfo, None, None]:
-    """
-    Gather details from installed distributions. Print distribution name,
-    version, location, and installed files. Installed files requires a
-    pip generated 'installed-files.txt' in the distributions '.egg-info'
-    directory.
-    """
-    env = get_default_environment()
-
-    installed = {dist.canonical_name: dist for dist in env.iter_all_distributions()}
-    query_names = [canonicalize_name(name) for name in query]
-    missing = sorted(
-        [name for name, pkg in zip(query, query_names) if pkg not in installed]
-    )
-    if missing:
-        logger.warning("Package(s) not found: %s", ", ".join(missing))
-
-    def _get_requiring_packages(current_dist: BaseDistribution) -> Iterator[str]:
-        return (
-            dist.metadata["Name"] or "UNKNOWN"
-            for dist in installed.values()
-            if current_dist.canonical_name
-            in {canonicalize_name(d.name) for d in dist.iter_dependencies()}
-        )
-
-    for query_name in query_names:
-        try:
-            dist = installed[query_name]
-        except KeyError:
-            continue
-
-        try:
-            requires = sorted(
-                # Avoid duplicates in requirements (e.g. due to environment markers).
-                {req.name for req in dist.iter_dependencies()},
-                key=str.lower,
-            )
-        except InvalidRequirement:
-            requires = sorted(dist.iter_raw_dependencies(), key=str.lower)
-
-        try:
-            required_by = sorted(_get_requiring_packages(dist), key=str.lower)
-        except InvalidRequirement:
-            required_by = ["#N/A"]
-
-        try:
-            entry_points_text = dist.read_text("entry_points.txt")
-            entry_points = entry_points_text.splitlines(keepends=False)
-        except FileNotFoundError:
-            entry_points = []
-
-        files_iter = dist.iter_declared_entries()
-        if files_iter is None:
-            files: list[str] | None = None
-        else:
-            files = sorted(files_iter)
-
-        metadata = dist.metadata
-
-        project_urls = metadata.get_all("Project-URL", [])
-        homepage = metadata.get("Home-page", "")
-        if not homepage:
-            # It's common that there is a "homepage" Project-URL, but Home-page
-            # remains unset (especially as PEP 621 doesn't surface the field).
-            for url in project_urls:
-                url_label, url = url.split(",", maxsplit=1)
-                normalized_label = normalize_project_url_label(url_label)
-                if normalized_label == "homepage":
-                    homepage = url.strip()
-                    break
-
-        yield _PackageInfo(
-            name=dist.raw_name,
-            version=dist.raw_version,
-            location=dist.location or "",
-            editable_project_location=dist.editable_project_location,
-            requires=requires,
-            required_by=required_by,
-            installer=dist.installer,
-            metadata_version=dist.metadata_version or "",
-            classifiers=metadata.get_all("Classifier", []),
-            summary=metadata.get("Summary", ""),
-            homepage=homepage,
-            project_urls=project_urls,
-            author=metadata.get("Author", ""),
-            author_email=metadata.get("Author-email", ""),
-            license=metadata.get("License", ""),
-            license_expression=metadata.get("License-Expression", ""),
-            entry_points=entry_points,
-            files=files,
-        )
-
-
-def print_results(
-    distributions: Iterable[_PackageInfo],
-    list_files: bool,
-    verbose: bool,
-) -> bool:
-    """
-    Print the information from installed distributions found.
-    """
-    results_printed = False
-    for i, dist in enumerate(distributions):
-        results_printed = True
-        if i > 0:
-            write_output("---")
-
-        metadata_version_tuple = tuple(map(int, dist.metadata_version.split(".")))
-
-        write_output("Name: %s", dist.name)
-        write_output("Version: %s", dist.version)
-        write_output("Summary: %s", dist.summary)
-        write_output("Home-page: %s", dist.homepage)
-        write_output("Author: %s", dist.author)
-        write_output("Author-email: %s", dist.author_email)
-        if metadata_version_tuple >= (2, 4) and dist.license_expression:
-            write_output("License-Expression: %s", dist.license_expression)
-        else:
-            write_output("License: %s", dist.license)
-        write_output("Location: %s", dist.location)
-        if dist.editable_project_location is not None:
-            write_output(
-                "Editable project location: %s", dist.editable_project_location
-            )
-        write_output("Requires: %s", ", ".join(dist.requires))
-        write_output("Required-by: %s", ", ".join(dist.required_by))
-
-        if verbose:
-            write_output("Metadata-Version: %s", dist.metadata_version)
-            write_output("Installer: %s", dist.installer)
-            write_output("Classifiers:")
-            for classifier in dist.classifiers:
-                write_output("  %s", classifier)
-            write_output("Entry-points:")
-            for entry in dist.entry_points:
-                write_output("  %s", entry.strip())
-            write_output("Project-URLs:")
-            for project_url in dist.project_urls:
-                write_output("  %s", project_url)
-        if list_files:
-            write_output("Files:")
-            if dist.files is None:
-                write_output("Cannot locate RECORD or installed-files.txt")
-            else:
-                for line in dist.files:
-                    write_output("  %s", line.strip())
-    return results_printed

venv/Lib/site-packages/pip/_internal/commands/uninstall.py

@@ -1,113 +0,0 @@
-import logging
-from optparse import Values
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.index_command import SessionCommandMixin
-from pip._internal.cli.status_codes import SUCCESS
-from pip._internal.exceptions import InstallationError
-from pip._internal.req import parse_requirements
-from pip._internal.req.constructors import (
-    install_req_from_line,
-    install_req_from_parsed_requirement,
-)
-from pip._internal.utils.misc import (
-    check_externally_managed,
-    protect_pip_from_modification_on_windows,
-    warn_if_run_as_root,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class UninstallCommand(Command, SessionCommandMixin):
-    """
-    Uninstall packages.
-
-    pip is able to uninstall most installed packages. Known exceptions are:
-
-    - Pure distutils packages installed with ``python setup.py install``, which
-      leave behind no metadata to determine what files were installed.
-    - Script wrappers installed by ``python setup.py develop``.
-    """
-
-    usage = """
-      %prog [options] <package> ...
-      %prog [options] -r <requirements file> ..."""
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "-r",
-            "--requirement",
-            dest="requirements",
-            action="append",
-            default=[],
-            metavar="file",
-            help=(
-                "Uninstall all the packages listed in the given requirements "
-                "file.  This option can be used multiple times."
-            ),
-        )
-        self.cmd_opts.add_option(
-            "-y",
-            "--yes",
-            dest="yes",
-            action="store_true",
-            help="Don't ask for confirmation of uninstall deletions.",
-        )
-        self.cmd_opts.add_option(cmdoptions.root_user_action())
-        self.cmd_opts.add_option(cmdoptions.override_externally_managed())
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: list[str]) -> int:
-        session = self.get_default_session(options)
-
-        reqs_to_uninstall = {}
-        for name in args:
-            req = install_req_from_line(
-                name,
-                isolated=options.isolated_mode,
-            )
-            if req.name:
-                reqs_to_uninstall[canonicalize_name(req.name)] = req
-            else:
-                logger.warning(
-                    "Invalid requirement: %r ignored -"
-                    " the uninstall command expects named"
-                    " requirements.",
-                    name,
-                )
-        for filename in options.requirements:
-            for parsed_req in parse_requirements(
-                filename, options=options, session=session
-            ):
-                req = install_req_from_parsed_requirement(
-                    parsed_req, isolated=options.isolated_mode
-                )
-                if req.name:
-                    reqs_to_uninstall[canonicalize_name(req.name)] = req
-        if not reqs_to_uninstall:
-            raise InstallationError(
-                f"You must give at least one requirement to {self.name} (see "
-                f'"pip help {self.name}")'
-            )
-
-        if not options.override_externally_managed:
-            check_externally_managed()
-
-        protect_pip_from_modification_on_windows(
-            modifying_pip="pip" in reqs_to_uninstall
-        )
-
-        for req in reqs_to_uninstall.values():
-            uninstall_pathset = req.uninstall(
-                auto_confirm=options.yes,
-                verbose=self.verbosity > 0,
-            )
-            if uninstall_pathset:
-                uninstall_pathset.commit()
-        if options.root_user_action == "warn":
-            warn_if_run_as_root()
-        return SUCCESS

venv/Lib/site-packages/pip/_internal/commands/wheel.py

@@ -1,176 +0,0 @@
-import logging
-import os
-import shutil
-from optparse import Values
-
-from pip._internal.cache import WheelCache
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.req_command import RequirementCommand, with_cleanup
-from pip._internal.cli.status_codes import SUCCESS
-from pip._internal.exceptions import CommandError
-from pip._internal.operations.build.build_tracker import get_build_tracker
-from pip._internal.req.req_install import (
-    InstallRequirement,
-)
-from pip._internal.utils.misc import ensure_dir, normalize_path
-from pip._internal.utils.temp_dir import TempDirectory
-from pip._internal.wheel_builder import build
-
-logger = logging.getLogger(__name__)
-
-
-class WheelCommand(RequirementCommand):
-    """
-    Build Wheel archives for your requirements and dependencies.
-
-    Wheel is a built-package format, and offers the advantage of not
-    recompiling your software during every install. For more details, see the
-    wheel docs: https://wheel.readthedocs.io/en/latest/
-
-    'pip wheel' uses the build system interface as described here:
-    https://pip.pypa.io/en/stable/reference/build-system/
-
-    """
-
-    usage = """
-      %prog [options] <requirement specifier> ...
-      %prog [options] -r <requirements file> ...
-      %prog [options] [-e] <vcs project url> ...
-      %prog [options] [-e] <local project path> ...
-      %prog [options] <archive url/path> ..."""
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "-w",
-            "--wheel-dir",
-            dest="wheel_dir",
-            metavar="dir",
-            default=os.curdir,
-            help=(
-                "Build wheels into <dir>, where the default is the "
-                "current working directory."
-            ),
-        )
-        self.cmd_opts.add_option(cmdoptions.no_binary())
-        self.cmd_opts.add_option(cmdoptions.only_binary())
-        self.cmd_opts.add_option(cmdoptions.prefer_binary())
-        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
-        self.cmd_opts.add_option(cmdoptions.use_pep517())
-        self.cmd_opts.add_option(cmdoptions.check_build_deps())
-        self.cmd_opts.add_option(cmdoptions.constraints())
-        self.cmd_opts.add_option(cmdoptions.build_constraints())
-        self.cmd_opts.add_option(cmdoptions.editable())
-        self.cmd_opts.add_option(cmdoptions.requirements())
-        self.cmd_opts.add_option(cmdoptions.src())
-        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
-        self.cmd_opts.add_option(cmdoptions.no_deps())
-        self.cmd_opts.add_option(cmdoptions.progress_bar())
-
-        self.cmd_opts.add_option(
-            "--no-verify",
-            dest="no_verify",
-            action="store_true",
-            default=False,
-            help="Don't verify if built wheel is valid.",
-        )
-
-        self.cmd_opts.add_option(cmdoptions.config_settings())
-
-        self.cmd_opts.add_option(
-            "--pre",
-            action="store_true",
-            default=False,
-            help=(
-                "Include pre-release and development versions. By default, "
-                "pip only finds stable versions."
-            ),
-        )
-
-        self.cmd_opts.add_option(cmdoptions.require_hashes())
-
-        index_opts = cmdoptions.make_option_group(
-            cmdoptions.index_group,
-            self.parser,
-        )
-
-        self.parser.insert_option_group(0, index_opts)
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    @with_cleanup
-    def run(self, options: Values, args: list[str]) -> int:
-        cmdoptions.check_build_constraints(options)
-
-        session = self.get_default_session(options)
-
-        finder = self._build_package_finder(options, session)
-
-        options.wheel_dir = normalize_path(options.wheel_dir)
-        ensure_dir(options.wheel_dir)
-
-        build_tracker = self.enter_context(get_build_tracker())
-
-        directory = TempDirectory(
-            delete=not options.no_clean,
-            kind="wheel",
-            globally_managed=True,
-        )
-
-        reqs = self.get_requirements(args, options, finder, session)
-
-        wheel_cache = WheelCache(options.cache_dir)
-
-        preparer = self.make_requirement_preparer(
-            temp_build_dir=directory,
-            options=options,
-            build_tracker=build_tracker,
-            session=session,
-            finder=finder,
-            download_dir=options.wheel_dir,
-            use_user_site=False,
-            verbosity=self.verbosity,
-        )
-
-        resolver = self.make_resolver(
-            preparer=preparer,
-            finder=finder,
-            options=options,
-            wheel_cache=wheel_cache,
-            ignore_requires_python=options.ignore_requires_python,
-        )
-
-        self.trace_basic_info(finder)
-
-        requirement_set = resolver.resolve(reqs, check_supported_wheels=True)
-
-        preparer.prepare_linked_requirements_more(requirement_set.requirements.values())
-
-        reqs_to_build: list[InstallRequirement] = []
-        for req in requirement_set.requirements.values():
-            if req.is_wheel:
-                preparer.save_linked_requirement(req)
-            else:
-                reqs_to_build.append(req)
-
-        # build wheels
-        build_successes, build_failures = build(
-            reqs_to_build,
-            wheel_cache=wheel_cache,
-            verify=(not options.no_verify),
-        )
-        for req in build_successes:
-            assert req.link and req.link.is_wheel
-            assert req.local_file_path
-            # copy from cache to target directory
-            try:
-                shutil.copy(req.local_file_path, options.wheel_dir)
-            except OSError as e:
-                logger.warning(
-                    "Building wheel for %s failed: %s",
-                    req.name,
-                    e,
-                )
-                build_failures.append(req)
-        if len(build_failures) != 0:
-            raise CommandError("Failed to build one or more wheels")
-
-        return SUCCESS