pip._internal.operations.freeze Namespace Reference

Data Structures
class	_EditableInfo
class	FrozenRequirement

Functions
Generator[str, None, None]	freeze (Optional[List[str]] requirement=None, bool local_only=False, bool user_only=False, Optional[List[str]] paths=None, bool isolated=False, bool exclude_editable=False, Container[str] skip=())
str	_format_as_name_version (BaseDistribution dist)
_EditableInfo	_get_editable_info (BaseDistribution dist)

Variables
	logger = logging.getLogger(__name__)

Function Documentation

_format_as_name_version()

str _format_as_name_version ( BaseDistribution  dist )

protected

Definition at line 147 of file freeze.py.

def _format_as_name_version(dist: BaseDistribution) -> str:
    dist_version = dist.version
    if isinstance(dist_version, Version):
        return f"{dist.raw_name}=={dist_version}"
    return f"{dist.raw_name}==={dist_version}"
 
 

References i.

Referenced by pip._internal.operations.freeze._get_editable_info(), and FrozenRequirement.from_dist().

Here is the caller graph for this function:

_get_editable_info()

_EditableInfo _get_editable_info ( BaseDistribution  dist )

protected

Compute and return values (req, comments) for use in
FrozenRequirement.from_dist().

Definition at line 154 of file freeze.py.

def _get_editable_info(dist: BaseDistribution) -> _EditableInfo:
    """
    Compute and return values (req, comments) for use in
    FrozenRequirement.from_dist().
    """
    editable_project_location = dist.editable_project_location
    assert editable_project_location
    location = os.path.normcase(os.path.abspath(editable_project_location))
 
    from pip._internal.vcs import RemoteNotFoundError, RemoteNotValidError, vcs
 
    vcs_backend = vcs.get_backend_for_dir(location)
 
    if vcs_backend is None:
        display = _format_as_name_version(dist)
        logger.debug(
            'No VCS found for editable requirement "%s" in: %r',
            display,
            location,
        )
        return _EditableInfo(
            requirement=location,
            comments=[f"# Editable install with no version control ({display})"],
        )
 
    vcs_name = type(vcs_backend).__name__
 
    try:
        req = vcs_backend.get_src_requirement(location, dist.raw_name)
    except RemoteNotFoundError:
        display = _format_as_name_version(dist)
        return _EditableInfo(
            requirement=location,
            comments=[f"# Editable {vcs_name} install with no remote ({display})"],
        )
    except RemoteNotValidError as ex:
        display = _format_as_name_version(dist)
        return _EditableInfo(
            requirement=location,
            comments=[
                f"# Editable {vcs_name} install ({display}) with either a deleted "
                f"local remote or invalid URI:",
                f"# '{ex.url}'",
            ],
        )
    except BadCommand:
        logger.warning(
            "cannot determine version of editable source in %s "
            "(%s command not found in path)",
            location,
            vcs_backend.name,
        )
        return _EditableInfo(requirement=location, comments=[])
    except InstallationError as exc:
        logger.warning("Error when trying to get requirement for VCS system %s", exc)
    else:
        return _EditableInfo(requirement=req, comments=[])
 
    logger.warning("Could not determine repository location of %s", location)
 
    return _EditableInfo(
        requirement=location,
        comments=["## !! Could not determine repository location"],
    )
 
 

References pip._internal.operations.freeze._format_as_name_version(), and i.

Referenced by FrozenRequirement.from_dist().

Here is the call graph for this function:

Here is the caller graph for this function:

freeze()

Generator[str, None, None] freeze	(	Optional[List[str]]	requirement = None,
		bool	local_only = False,
		bool	user_only = False,
		Optional[List[str]]	paths = None,
		bool	isolated = False,
		bool	exclude_editable = False,
		Container[str]	skip = ()
	)

Definition at line 26 of file freeze.py.

) -> Generator[str, None, None]:
    installations: Dict[str, FrozenRequirement] = {}
 
    dists = get_environment(paths).iter_installed_distributions(
        local_only=local_only,
        skip=(),
        user_only=user_only,
    )
    for dist in dists:
        req = FrozenRequirement.from_dist(dist)
        if exclude_editable and req.editable:
            continue
        installations[req.canonical_name] = req
 
    if requirement:
        # the options that don't get turned into an InstallRequirement
        # should only be emitted once, even if the same option is in multiple
        # requirements files, so we need to keep track of what has been emitted
        # so that we don't emit it again if it's seen again
        emitted_options: Set[str] = set()
        # keep track of which files a requirement is in so that we can
        # give an accurate warning if a requirement appears multiple times.
        req_files: Dict[str, List[str]] = collections.defaultdict(list)
        for req_file_path in requirement:
            with open(req_file_path) as req_file:
                for line in req_file:
                    if (
                        not line.strip()
                        or line.strip().startswith("#")
                        or line.startswith(
                            (
                                "-r",
                                "--requirement",
                                "-f",
                                "--find-links",
                                "-i",
                                "--index-url",
                                "--pre",
                                "--trusted-host",
                                "--process-dependency-links",
                                "--extra-index-url",
                                "--use-feature",
                            )
                        )
                    ):
                        line = line.rstrip()
                        if line not in emitted_options:
                            emitted_options.add(line)
                            yield line
                        continue
 
                    if line.startswith("-e") or line.startswith("--editable"):
                        if line.startswith("-e"):
                            line = line[2:].strip()
                        else:
                            line = line[len("--editable") :].strip().lstrip("=")
                        line_req = install_req_from_editable(
                            line,
                            isolated=isolated,
                        )
                    else:
                        line_req = install_req_from_line(
                            COMMENT_RE.sub("", line).strip(),
                            isolated=isolated,
                        )
 
                    if not line_req.name:
                        logger.info(
                            "Skipping line in requirement file [%s] because "
                            "it's not clear what it would install: %s",
                            req_file_path,
                            line.strip(),
                        )
                        logger.info(
                            "  (add #egg=PackageName to the URL to avoid"
                            " this warning)"
                        )
                    else:
                        line_req_canonical_name = canonicalize_name(line_req.name)
                        if line_req_canonical_name not in installations:
                            # either it's not installed, or it is installed
                            # but has been processed already
                            if not req_files[line_req.name]:
                                logger.warning(
                                    "Requirement file [%s] contains %s, but "
                                    "package %r is not installed",
                                    req_file_path,
                                    COMMENT_RE.sub("", line).strip(),
                                    line_req.name,
                                )
                            else:
                                req_files[line_req.name].append(req_file_path)
                        else:
                            yield str(installations[line_req_canonical_name]).rstrip()
                            del installations[line_req_canonical_name]
                            req_files[line_req.name].append(req_file_path)
 
        # Warn about requirements that were included multiple times (in a
        # single requirements file or in different requirements files).
        for name, files in req_files.items():
            if len(files) > 1:
                logger.warning(
                    "Requirement %s included multiple times [%s]",
                    name,
                    ", ".join(sorted(set(files))),
                )
 
        yield ("## The following requirements were added by pip freeze:")
    for installation in sorted(installations.values(), key=lambda x: x.name.lower()):
        if installation.canonical_name not in skip:
            yield str(installation).rstrip()
 
 

References i.

Variable Documentation

logger

logger = logging.getLogger(__name__)

Definition at line 18 of file freeze.py.