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

   1 import logging
   2 from optparse import Values
   3 from typing import Any, Iterable, List, Optional, Union
   4
   5 from pip._vendor.packaging.version import LegacyVersion, Version
   6
   7 from pip._internal.cli import cmdoptions
   8 from pip._internal.cli.req_command import IndexGroupCommand
   9 from pip._internal.cli.status_codes import ERROR, SUCCESS
  10 from pip._internal.commands.search import print_dist_installation_info
  11 from pip._internal.exceptions import CommandError, DistributionNotFound, PipError
  12 from pip._internal.index.collector import LinkCollector
  13 from pip._internal.index.package_finder import PackageFinder
  14 from pip._internal.models.selection_prefs import SelectionPreferences
  15 from pip._internal.models.target_python import TargetPython
  16 from pip._internal.network.session import PipSession
  17 from pip._internal.utils.misc import write_output
  18
  19 logger = logging.getLogger(__name__)
  20
  21
  22 class IndexCommand(IndexGroupCommand):
  23     """
  24     Inspect information available from package indexes.
  25     """
  26
  27     ignore_require_venv = True
  28     usage = """
  29         %prog versions <package>
  30     """
  31
  32     def add_options(self) -> None:
  33         cmdoptions.add_target_python_options(self.cmd_opts)
  34
  35         self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
  36         self.cmd_opts.add_option(cmdoptions.pre())
  37         self.cmd_opts.add_option(cmdoptions.no_binary())
  38         self.cmd_opts.add_option(cmdoptions.only_binary())
  39
  40         index_opts = cmdoptions.make_option_group(
  41             cmdoptions.index_group,
  42             self.parser,
  43         )
  44
  45         self.parser.insert_option_group(0, index_opts)
  46         self.parser.insert_option_group(0, self.cmd_opts)
  47
  48     def run(self, options: Values, args: List[str]) -> int:
  49         handlers = {
  50             "versions": self.get_available_package_versions,
  51         }
  52
  53         logger.warning(
  54             "pip index is currently an experimental command. "
  55             "It may be removed/changed in a future release "
  56             "without prior warning."
  57         )
  58
  59         # Determine action
  60         if not args or args[0] not in handlers:
  61             logger.error(
  62                 "Need an action (%s) to perform.",
  63                 ", ".join(sorted(handlers)),
  64             )
  65             return ERROR
  66
  67         action = args[0]
  68
  69         # Error handling happens here, not in the action-handlers.
  70         try:
  71             handlers[action](options, args[1:])
  72         except PipError as e:
  73             logger.error(e.args[0])
  74             return ERROR
  75
  76         return SUCCESS
  77
  78     def _build_package_finder(
  79         self,
  80         options: Values,
  81         session: PipSession,
  82         target_python: Optional[TargetPython] = None,
  83         ignore_requires_python: Optional[bool] = None,
  84     ) -> PackageFinder:
  85         """
  86         Create a package finder appropriate to the index command.
  87         """
  88         link_collector = LinkCollector.create(session, options=options)
  89
  90         # Pass allow_yanked=False to ignore yanked versions.
  91         selection_prefs = SelectionPreferences(
  92             allow_yanked=False,
  93             allow_all_prereleases=options.pre,
  94             ignore_requires_python=ignore_requires_python,
  95         )
  96
  97         return PackageFinder.create(
  98             link_collector=link_collector,
  99             selection_prefs=selection_prefs,
 100             target_python=target_python,
 101         )
 102
 103     def get_available_package_versions(self, options: Values, args: List[Any]) -> None:
 104         if len(args) != 1:
 105             raise CommandError("You need to specify exactly one argument")
 106
 107         target_python = cmdoptions.make_target_python(options)
 108         query = args[0]
 109
 110         with self._build_session(options) as session:
 111             finder = self._build_package_finder(
 112                 options=options,
 113                 session=session,
 114                 target_python=target_python,
 115                 ignore_requires_python=options.ignore_requires_python,
 116             )
 117
 118             versions: Iterable[Union[LegacyVersion, Version]] = (
 119                 candidate.version for candidate in finder.find_all_candidates(query)
 120             )
 121
 122             if not options.pre:
 123                 # Remove prereleases
 124                 versions = (
 125                     version for version in versions if not version.is_prerelease
 126                 )
 127             versions = set(versions)
 128
 129             if not versions:
 130                 raise DistributionNotFound(
 131                     "No matching distribution found for {}".format(query)
 132                 )
 133
 134             formatted_versions = [str(ver) for ver in sorted(versions, reverse=True)]
 135             latest = formatted_versions[0]
 136
 137         write_output("{} ({})".format(query, latest))
 138         write_output("Available versions: {}".format(", ".join(formatted_versions)))
 139         print_dist_installation_info(query, latest)