python (3.11.7)

(root)/
lib/
python3.11/
site-packages/
pip/
_internal/
cli/
main_parser.py
       1  """A single place for constructing and exposing the main parser
       2  """
       3  
       4  import os
       5  import subprocess
       6  import sys
       7  from typing import List, Optional, Tuple
       8  
       9  from pip._internal.build_env import get_runnable_pip
      10  from pip._internal.cli import cmdoptions
      11  from pip._internal.cli.parser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
      12  from pip._internal.commands import commands_dict, get_similar_commands
      13  from pip._internal.exceptions import CommandError
      14  from pip._internal.utils.misc import get_pip_version, get_prog
      15  
      16  __all__ = ["create_main_parser", "parse_command"]
      17  
      18  
      19  def create_main_parser() -> ConfigOptionParser:
      20      """Creates and returns the main parser for pip's CLI"""
      21  
      22      parser = ConfigOptionParser(
      23          usage="\n%prog <command> [options]",
      24          add_help_option=False,
      25          formatter=UpdatingDefaultsHelpFormatter(),
      26          name="global",
      27          prog=get_prog(),
      28      )
      29      parser.disable_interspersed_args()
      30  
      31      parser.version = get_pip_version()
      32  
      33      # add the general options
      34      gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
      35      parser.add_option_group(gen_opts)
      36  
      37      # so the help formatter knows
      38      parser.main = True  # type: ignore
      39  
      40      # create command listing for description
      41      description = [""] + [
      42          f"{name:27} {command_info.summary}"
      43          for name, command_info in commands_dict.items()
      44      ]
      45      parser.description = "\n".join(description)
      46  
      47      return parser
      48  
      49  
      50  def identify_python_interpreter(python: str) -> Optional[str]:
      51      # If the named file exists, use it.
      52      # If it's a directory, assume it's a virtual environment and
      53      # look for the environment's Python executable.
      54      if os.path.exists(python):
      55          if os.path.isdir(python):
      56              # bin/python for Unix, Scripts/python.exe for Windows
      57              # Try both in case of odd cases like cygwin.
      58              for exe in ("bin/python", "Scripts/python.exe"):
      59                  py = os.path.join(python, exe)
      60                  if os.path.exists(py):
      61                      return py
      62          else:
      63              return python
      64  
      65      # Could not find the interpreter specified
      66      return None
      67  
      68  
      69  def parse_command(args: List[str]) -> Tuple[str, List[str]]:
      70      parser = create_main_parser()
      71  
      72      # Note: parser calls disable_interspersed_args(), so the result of this
      73      # call is to split the initial args into the general options before the
      74      # subcommand and everything else.
      75      # For example:
      76      #  args: ['--timeout=5', 'install', '--user', 'INITools']
      77      #  general_options: ['--timeout==5']
      78      #  args_else: ['install', '--user', 'INITools']
      79      general_options, args_else = parser.parse_args(args)
      80  
      81      # --python
      82      if general_options.python and "_PIP_RUNNING_IN_SUBPROCESS" not in os.environ:
      83          # Re-invoke pip using the specified Python interpreter
      84          interpreter = identify_python_interpreter(general_options.python)
      85          if interpreter is None:
      86              raise CommandError(
      87                  f"Could not locate Python interpreter {general_options.python}"
      88              )
      89  
      90          pip_cmd = [
      91              interpreter,
      92              get_runnable_pip(),
      93          ]
      94          pip_cmd.extend(args)
      95  
      96          # Set a flag so the child doesn't re-invoke itself, causing
      97          # an infinite loop.
      98          os.environ["_PIP_RUNNING_IN_SUBPROCESS"] = "1"
      99          returncode = 0
     100          try:
     101              proc = subprocess.run(pip_cmd)
     102              returncode = proc.returncode
     103          except (subprocess.SubprocessError, OSError) as exc:
     104              raise CommandError(f"Failed to run pip under {interpreter}: {exc}")
     105          sys.exit(returncode)
     106  
     107      # --version
     108      if general_options.version:
     109          sys.stdout.write(parser.version)
     110          sys.stdout.write(os.linesep)
     111          sys.exit()
     112  
     113      # pip || pip help -> print_help()
     114      if not args_else or (args_else[0] == "help" and len(args_else) == 1):
     115          parser.print_help()
     116          sys.exit()
     117  
     118      # the subcommand name
     119      cmd_name = args_else[0]
     120  
     121      if cmd_name not in commands_dict:
     122          guess = get_similar_commands(cmd_name)
     123  
     124          msg = [f'unknown command "{cmd_name}"']
     125          if guess:
     126              msg.append(f'maybe you meant "{guess}"')
     127  
     128          raise CommandError(" - ".join(msg))
     129  
     130      # all the args without the subcommand
     131      cmd_args = args[:]
     132      cmd_args.remove(cmd_name)
     133  
     134      return cmd_name, cmd_args