@motiadev/core 0.2.1-beta.58 → 0.2.1-beta.59

package/python_modules/lib/python3.11/site-packages/pip/_internal/commands/freeze.py

@@ -1,108 +0,0 @@
-import sys
-from optparse import Values
-from typing import AbstractSet, List
-
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import SUCCESS
-from pip._internal.operations.freeze import freeze
-from pip._internal.utils.compat import stdlib_pkgs
-
-
-def _should_suppress_build_backends() -> bool:
-    return sys.version_info < (3, 12)
-
-
-def _dev_pkgs() -> AbstractSet[str]:
-    pkgs = {"pip"}
-
-    if _should_suppress_build_backends():
-        pkgs |= {"setuptools", "distribute", "wheel"}
-
-    return pkgs
-
-
-class FreezeCommand(Command):
-    """
-    Output installed packages in requirements format.
-
-    packages are listed in a case-insensitive sorted order.
-    """
-
-    usage = """
-      %prog [options]"""
-    log_streams = ("ext://sys.stderr", "ext://sys.stderr")
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "-r",
-            "--requirement",
-            dest="requirements",
-            action="append",
-            default=[],
-            metavar="file",
-            help=(
-                "Use the order in the given requirements file and its "
-                "comments when generating output. This option can be "
-                "used multiple times."
-            ),
-        )
-        self.cmd_opts.add_option(
-            "-l",
-            "--local",
-            dest="local",
-            action="store_true",
-            default=False,
-            help=(
-                "If in a virtualenv that has global access, do not output "
-                "globally-installed packages."
-            ),
-        )
-        self.cmd_opts.add_option(
-            "--user",
-            dest="user",
-            action="store_true",
-            default=False,
-            help="Only output packages installed in user-site.",
-        )
-        self.cmd_opts.add_option(cmdoptions.list_path())
-        self.cmd_opts.add_option(
-            "--all",
-            dest="freeze_all",
-            action="store_true",
-            help=(
-                "Do not skip these packages in the output:"
-                " {}".format(", ".join(_dev_pkgs()))
-            ),
-        )
-        self.cmd_opts.add_option(
-            "--exclude-editable",
-            dest="exclude_editable",
-            action="store_true",
-            help="Exclude editable package from output.",
-        )
-        self.cmd_opts.add_option(cmdoptions.list_exclude())
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: List[str]) -> int:
-        skip = set(stdlib_pkgs)
-        if not options.freeze_all:
-            skip.update(_dev_pkgs())
-
-        if options.excludes:
-            skip.update(options.excludes)
-
-        cmdoptions.check_list_path_option(options)
-
-        for line in freeze(
-            requirement=options.requirements,
-            local_only=options.local,
-            user_only=options.user,
-            paths=options.path,
-            isolated=options.isolated_mode,
-            skip=skip,
-            exclude_editable=options.exclude_editable,
-        ):
-            sys.stdout.write(line + "\n")
-        return SUCCESS

package/python_modules/lib/python3.11/site-packages/pip/_internal/commands/hash.py

@@ -1,59 +0,0 @@
-import hashlib
-import logging
-import sys
-from optparse import Values
-from typing import List
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.utils.hashes import FAVORITE_HASH, STRONG_HASHES
-from pip._internal.utils.misc import read_chunks, write_output
-
-logger = logging.getLogger(__name__)
-
-
-class HashCommand(Command):
-    """
-    Compute a hash of a local package archive.
-
-    These can be used with --hash in a requirements file to do repeatable
-    installs.
-    """
-
-    usage = "%prog [options] <file> ..."
-    ignore_require_venv = True
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "-a",
-            "--algorithm",
-            dest="algorithm",
-            choices=STRONG_HASHES,
-            action="store",
-            default=FAVORITE_HASH,
-            help="The hash algorithm to use: one of {}".format(
-                ", ".join(STRONG_HASHES)
-            ),
-        )
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: List[str]) -> int:
-        if not args:
-            self.parser.print_usage(sys.stderr)
-            return ERROR
-
-        algorithm = options.algorithm
-        for path in args:
-            write_output(
-                "%s:\n--hash=%s:%s", path, algorithm, _hash_of_file(path, algorithm)
-            )
-        return SUCCESS
-
-
-def _hash_of_file(path: str, algorithm: str) -> str:
-    """Return the hash digest of a file."""
-    with open(path, "rb") as archive:
-        hash = hashlib.new(algorithm)
-        for chunk in read_chunks(archive):
-            hash.update(chunk)
-    return hash.hexdigest()

package/python_modules/lib/python3.11/site-packages/pip/_internal/commands/help.py

@@ -1,41 +0,0 @@
-from optparse import Values
-from typing import List
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import SUCCESS
-from pip._internal.exceptions import CommandError
-
-
-class HelpCommand(Command):
-    """Show help for commands"""
-
-    usage = """
-      %prog <command>"""
-    ignore_require_venv = True
-
-    def run(self, options: Values, args: List[str]) -> int:
-        from pip._internal.commands import (
-            commands_dict,
-            create_command,
-            get_similar_commands,
-        )
-
-        try:
-            # 'pip help' with no args is handled by pip.__init__.parseopt()
-            cmd_name = args[0]  # the command we need help for
-        except IndexError:
-            return SUCCESS
-
-        if cmd_name not in commands_dict:
-            guess = get_similar_commands(cmd_name)
-
-            msg = [f'unknown command "{cmd_name}"']
-            if guess:
-                msg.append(f'maybe you meant "{guess}"')
-
-            raise CommandError(" - ".join(msg))
-
-        command = create_command(cmd_name)
-        command.parser.print_help()
-
-        return SUCCESS

package/python_modules/lib/python3.11/site-packages/pip/_internal/commands/index.py

@@ -1,139 +0,0 @@
-import logging
-from optparse import Values
-from typing import Any, Iterable, List, Optional, Union
-
-from pip._vendor.packaging.version import LegacyVersion, Version
-
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.req_command import IndexGroupCommand
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.commands.search import print_dist_installation_info
-from pip._internal.exceptions import CommandError, DistributionNotFound, PipError
-from pip._internal.index.collector import LinkCollector
-from pip._internal.index.package_finder import PackageFinder
-from pip._internal.models.selection_prefs import SelectionPreferences
-from pip._internal.models.target_python import TargetPython
-from pip._internal.network.session import PipSession
-from pip._internal.utils.misc import write_output
-
-logger = logging.getLogger(__name__)
-
-
-class IndexCommand(IndexGroupCommand):
-    """
-    Inspect information available from package indexes.
-    """
-
-    ignore_require_venv = True
-    usage = """
-        %prog versions <package>
-    """
-
-    def add_options(self) -> None:
-        cmdoptions.add_target_python_options(self.cmd_opts)
-
-        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
-        self.cmd_opts.add_option(cmdoptions.pre())
-        self.cmd_opts.add_option(cmdoptions.no_binary())
-        self.cmd_opts.add_option(cmdoptions.only_binary())
-
-        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)
-
-    def run(self, options: Values, args: List[str]) -> int:
-        handlers = {
-            "versions": self.get_available_package_versions,
-        }
-
-        logger.warning(
-            "pip index is currently an experimental command. "
-            "It may be removed/changed in a future release "
-            "without prior warning."
-        )
-
-        # Determine action
-        if not args or args[0] not in handlers:
-            logger.error(
-                "Need an action (%s) to perform.",
-                ", ".join(sorted(handlers)),
-            )
-            return ERROR
-
-        action = args[0]
-
-        # Error handling happens here, not in the action-handlers.
-        try:
-            handlers[action](options, args[1:])
-        except PipError as e:
-            logger.error(e.args[0])
-            return ERROR
-
-        return SUCCESS
-
-    def _build_package_finder(
-        self,
-        options: Values,
-        session: PipSession,
-        target_python: Optional[TargetPython] = None,
-        ignore_requires_python: Optional[bool] = None,
-    ) -> PackageFinder:
-        """
-        Create a package finder appropriate to the index command.
-        """
-        link_collector = LinkCollector.create(session, options=options)
-
-        # Pass allow_yanked=False to ignore yanked versions.
-        selection_prefs = SelectionPreferences(
-            allow_yanked=False,
-            allow_all_prereleases=options.pre,
-            ignore_requires_python=ignore_requires_python,
-        )
-
-        return PackageFinder.create(
-            link_collector=link_collector,
-            selection_prefs=selection_prefs,
-            target_python=target_python,
-        )
-
-    def get_available_package_versions(self, options: Values, args: List[Any]) -> None:
-        if len(args) != 1:
-            raise CommandError("You need to specify exactly one argument")
-
-        target_python = cmdoptions.make_target_python(options)
-        query = args[0]
-
-        with self._build_session(options) as session:
-            finder = self._build_package_finder(
-                options=options,
-                session=session,
-                target_python=target_python,
-                ignore_requires_python=options.ignore_requires_python,
-            )
-
-            versions: Iterable[Union[LegacyVersion, Version]] = (
-                candidate.version for candidate in finder.find_all_candidates(query)
-            )
-
-            if not options.pre:
-                # Remove prereleases
-                versions = (
-                    version for version in versions if not version.is_prerelease
-                )
-            versions = set(versions)
-
-            if not versions:
-                raise DistributionNotFound(
-                    f"No matching distribution found for {query}"
-                )
-
-            formatted_versions = [str(ver) for ver in sorted(versions, reverse=True)]
-            latest = formatted_versions[0]
-
-        write_output(f"{query} ({latest})")
-        write_output("Available versions: {}".format(", ".join(formatted_versions)))
-        print_dist_installation_info(query, latest)

package/python_modules/lib/python3.11/site-packages/pip/_internal/commands/inspect.py

@@ -1,92 +0,0 @@
-import logging
-from optparse import Values
-from typing import Any, Dict, List
-
-from pip._vendor.packaging.markers import default_environment
-from pip._vendor.rich import print_json
-
-from pip import __version__
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.req_command import Command
-from pip._internal.cli.status_codes import SUCCESS
-from pip._internal.metadata import BaseDistribution, get_environment
-from pip._internal.utils.compat import stdlib_pkgs
-from pip._internal.utils.urls import path_to_url
-
-logger = logging.getLogger(__name__)
-
-
-class InspectCommand(Command):
-    """
-    Inspect the content of a Python environment and produce a report in JSON format.
-    """
-
-    ignore_require_venv = True
-    usage = """
-      %prog [options]"""
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "--local",
-            action="store_true",
-            default=False,
-            help=(
-                "If in a virtualenv that has global access, do not list "
-                "globally-installed packages."
-            ),
-        )
-        self.cmd_opts.add_option(
-            "--user",
-            dest="user",
-            action="store_true",
-            default=False,
-            help="Only output packages installed in user-site.",
-        )
-        self.cmd_opts.add_option(cmdoptions.list_path())
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: List[str]) -> int:
-        cmdoptions.check_list_path_option(options)
-        dists = get_environment(options.path).iter_installed_distributions(
-            local_only=options.local,
-            user_only=options.user,
-            skip=set(stdlib_pkgs),
-        )
-        output = {
-            "version": "1",
-            "pip_version": __version__,
-            "installed": [self._dist_to_dict(dist) for dist in dists],
-            "environment": default_environment(),
-            # TODO tags? scheme?
-        }
-        print_json(data=output)
-        return SUCCESS
-
-    def _dist_to_dict(self, dist: BaseDistribution) -> Dict[str, Any]:
-        res: Dict[str, Any] = {
-            "metadata": dist.metadata_dict,
-            "metadata_location": dist.info_location,
-        }
-        # direct_url. Note that we don't have download_info (as in the installation
-        # report) since it is not recorded in installed metadata.
-        direct_url = dist.direct_url
-        if direct_url is not None:
-            res["direct_url"] = direct_url.to_dict()
-        else:
-            # Emulate direct_url for legacy editable installs.
-            editable_project_location = dist.editable_project_location
-            if editable_project_location is not None:
-                res["direct_url"] = {
-                    "url": path_to_url(editable_project_location),
-                    "dir_info": {
-                        "editable": True,
-                    },
-                }
-        # installer
-        installer = dist.installer
-        if dist.installer:
-            res["installer"] = installer
-        # requested
-        if dist.installed_with_dist_info:
-            res["requested"] = dist.requested
-        return res