import logging
from optparse
import Values
from typing
import Generator, Iterable, Iterator, List, NamedTuple, Optional
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__)
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: Optional[str]
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
entry_points: List[str]
files: Optional[List[str]]
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
requires = sorted((req.name
for req
in dist.iter_dependencies()), key=str.lower)
required_by = sorted(_get_requiring_packages(dist), key=str.lower)
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: Optional[List[str]] =
None
else:
files = sorted(files_iter)
metadata = dist.metadata
yield _PackageInfo(
name=dist.raw_name,
version=str(dist.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=metadata.get(
"Home-page",
""),
project_urls=metadata.get_all(
"Project-URL", []),
author=metadata.get(
"Author",
""),
author_email=metadata.get(
"Author-email",
""),
license=metadata.get(
"License",
""),
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(
"---")
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)
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
