index.py

from __future__ import annotations

import json
import logging
from collections.abc import Iterable
from optparse import Values
from typing import Any, Callable

from pip._vendor.packaging.utils import canonicalize_name
from pip._vendor.packaging.version import 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 (
    get_installed_distribution,
    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.json())

index_opts = cmdoptions.make_option_group(
            cmdoptions.index_group,
            self.parser,
        )

selection_opts = cmdoptions.make_option_group(
            cmdoptions.package_selection_group,
            self.parser,
        )

self.parser.insert_option_group(0, index_opts)
        self.parser.insert_option_group(0, selection_opts)
        self.parser.insert_option_group(0, self.cmd_opts)

def handler_map(self) -> dict[str, Callable[[Values, list[str]], None]]:
        return {
            "versions": self.get_available_package_versions,
        }

def run(self, options: Values, args: list[str]) -> int:
        cmdoptions.check_release_control_exclusive(options)

handler_map = self.handler_map()

# Determine action
        if not args or args[0] not in handler_map:
            logger.error(
                "Need an action (%s) to perform.",
                ", ".join(sorted(handler_map)),
            )
            return ERROR

action = args[0]

# Error handling happens here, not in the action-handlers.
        try:
            handler_map[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: TargetPython | None = None,
        ignore_requires_python: bool = False,
    ) -> 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,
            release_control=options.release_control,
            format_control=options.format_control,
            ignore_requires_python=ignore_requires_python,
        )

return PackageFinder.create(
            link_collector=link_collector,
            selection_prefs=selection_prefs,
            target_python=target_python,
            uploaded_prior_to=options.uploaded_prior_to,
        )

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[Version] = (
                candidate.version for candidate in finder.find_all_candidates(query)
            )

if self.should_exclude_prerelease(options, canonicalize_name(query)):
                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]

dist = get_installed_distribution(query)

if options.json:
            structured_output = {
                "name": query,
                "versions": formatted_versions,
                "latest": latest,
            }

if dist is not None:
                structured_output["installed_version"] = str(dist.version)

write_output(json.dumps(structured_output))

else:
            write_output(f"{query} ({latest})")
            write_output("Available versions: {}".format(", ".join(formatted_versions)))
            print_dist_installation_info(latest, dist)

docroot: /home/induvedam/public_html

curdir: /opt/imunify360/venv/lib/python3.11/site-packages/pip/_internal/commands

	.	4096
	..	4096
X	__init__.py	4026
	__pycache__	4096
X	cache.py	9142
X	check.py	2244
X	completion.py	4565
X	configuration.py	10105
X	debug.py	6543
X	download.py	5178
X	freeze.py	3099
X	hash.py	1679
X	help.py	1108
X	index.py	5514
X	inspect.py	3184
X	install.py	33733
X	list.py	13638
X	lock.py	6027
X	search.py	5782
X	show.py	8066
X	uninstall.py	3868
X	wheel.py	5880