pip._internal.req.req_uninstall Namespace Reference

Data Structures
class	StashedUninstallPathSet
class	UninstallPathSet
class	UninstallPthEntries

Functions
Generator[str, None, None]	_script_names (str bin_dir, str script_name, bool is_gui)
Callable[..., Generator[Any, None, None]]	_unique (Callable[..., Generator[Any, None, None]] fn)
Generator[str, None, None]	uninstallation_paths (BaseDistribution dist)
Set[str]	compact (Iterable[str] paths)
Set[str]	compress_for_rename (Iterable[str] paths)
Tuple[Set[str], Set[str]]	compress_for_output_listing (Iterable[str] paths)

Variables
	logger = getLogger(__name__)

Function Documentation

_script_names()

Generator[str, None, None] _script_names ( str  bin_dir, str  script_name, bool   is_gui  )

protected

Create the fully qualified name of the files created by
{console,gui}_scripts for the given ``dist``.
Returns the list of file names

Definition at line 21 of file req_uninstall.py.

) -> Generator[str, None, None]:
    """Create the fully qualified name of the files created by
    {console,gui}_scripts for the given ``dist``.
    Returns the list of file names
    """
    exe_name = os.path.join(bin_dir, script_name)
    yield exe_name
    if not WINDOWS:
        return
    yield f"{exe_name}.exe"
    yield f"{exe_name}.exe.manifest"
    if is_gui:
        yield f"{exe_name}-script.pyw"
    else:
        yield f"{exe_name}-script.py"
 
 

References i.

Referenced by UninstallPathSet.from_dist().

Here is the caller graph for this function:

_unique()

Callable[..., Generator[Any, None, None]] _unique ( Callable[..., Generator[Any, None, None]]   fn )

protected

Definition at line 40 of file req_uninstall.py.

) -> Callable[..., Generator[Any, None, None]]:
    @functools.wraps(fn)
    def unique(*args: Any, **kw: Any) -> Generator[Any, None, None]:
        seen: Set[Any] = set()
        for item in fn(*args, **kw):
            if item not in seen:
                seen.add(item)
                yield item
 
    return unique
 
 
@_unique

References i.

compact()

Set[str] compact

(

Iterable[str]

paths

)

Compact a path set to contain the minimal number of paths
necessary to contain all paths in the set. If /a/path/ and
/a/path/to/a/file.txt are both in the set, leave only the
shorter path.

Definition at line 98 of file req_uninstall.py.

def compact(paths: Iterable[str]) -> Set[str]:
    """Compact a path set to contain the minimal number of paths
    necessary to contain all paths in the set. If /a/path/ and
    /a/path/to/a/file.txt are both in the set, leave only the
    shorter path."""
 
    sep = os.path.sep
    short_paths: Set[str] = set()
    for path in sorted(paths, key=len):
        should_skip = any(
            path.startswith(shortpath.rstrip("*"))
            and path[len(shortpath.rstrip("*").rstrip(sep))] == sep
            for shortpath in short_paths
        )
        if not should_skip:
            short_paths.add(path)
    return short_paths
 
 

References i.

Referenced by UninstallPathSet._allowed_to_proceed(), pip._internal.req.req_uninstall.compress_for_output_listing(), and UninstallPathSet.remove().

Here is the caller graph for this function:

compress_for_output_listing()

Tuple[Set[str], Set[str]] compress_for_output_listing

(

Iterable[str]

paths

)

Returns a tuple of 2 sets of which paths to display to user

The first set contains paths that would be deleted. Files of a package
are not added and the top-level directory of the package has a '*' added
at the end - to signify that all it's contents are removed.

The second set contains files that would have been skipped in the above
folders.

Definition at line 151 of file req_uninstall.py.

def compress_for_output_listing(paths: Iterable[str]) -> Tuple[Set[str], Set[str]]:
    """Returns a tuple of 2 sets of which paths to display to user
 
    The first set contains paths that would be deleted. Files of a package
    are not added and the top-level directory of the package has a '*' added
    at the end - to signify that all it's contents are removed.
 
    The second set contains files that would have been skipped in the above
    folders.
    """
 
    will_remove = set(paths)
    will_skip = set()
 
    # Determine folders and files
    folders = set()
    files = set()
    for path in will_remove:
        if path.endswith(".pyc"):
            continue
        if path.endswith("__init__.py") or ".dist-info" in path:
            folders.add(os.path.dirname(path))
        files.add(path)
 
    # probably this one https://github.com/python/mypy/issues/390
    _normcased_files = set(map(os.path.normcase, files))  # type: ignore
 
    folders = compact(folders)
 
    # This walks the tree using os.walk to not miss extra folders
    # that might get added.
    for folder in folders:
        for dirpath, _, dirfiles in os.walk(folder):
            for fname in dirfiles:
                if fname.endswith(".pyc"):
                    continue
 
                file_ = os.path.join(dirpath, fname)
                if (
                    os.path.isfile(file_)
                    and os.path.normcase(file_) not in _normcased_files
                ):
                    # We are skipping this file. Add it to the set.
                    will_skip.add(file_)
 
    will_remove = files | {os.path.join(folder, "*") for folder in folders}
 
    return will_remove, will_skip
 
 

References pip._internal.req.req_uninstall.compact(), and i.

Referenced by UninstallPathSet._allowed_to_proceed().

Here is the call graph for this function:

Here is the caller graph for this function:

compress_for_rename()

Set[str] compress_for_rename

(

Iterable[str]

paths

)

Returns a set containing the paths that need to be renamed.

This set may include directories when the original sequence of paths
included every file on disk.

Definition at line 117 of file req_uninstall.py.

def compress_for_rename(paths: Iterable[str]) -> Set[str]:
    """Returns a set containing the paths that need to be renamed.
 
    This set may include directories when the original sequence of paths
    included every file on disk.
    """
    case_map = {os.path.normcase(p): p for p in paths}
    remaining = set(case_map)
    unchecked = sorted({os.path.split(p)[0] for p in case_map.values()}, key=len)
    wildcards: Set[str] = set()
 
    def norm_join(*a: str) -> str:
        return os.path.normcase(os.path.join(*a))
 
    for root in unchecked:
        if any(os.path.normcase(root).startswith(w) for w in wildcards):
            # This directory has already been handled.
            continue
 
        all_files: Set[str] = set()
        all_subdirs: Set[str] = set()
        for dirname, subdirs, files in os.walk(root):
            all_subdirs.update(norm_join(root, dirname, d) for d in subdirs)
            all_files.update(norm_join(root, dirname, f) for f in files)
        # If all the files we found are in our remaining set of files to
        # remove, then remove them from the latter set and add a wildcard
        # for the directory.
        if not (all_files - remaining):
            remaining.difference_update(all_files)
            wildcards.add(root + os.sep)
 
    return set(map(case_map.__getitem__, remaining)) | wildcards
 
 

References i.

Referenced by UninstallPathSet.remove().

Here is the caller graph for this function:

uninstallation_paths()

Generator[str, None, None] uninstallation_paths

(

BaseDistribution

dist

)

Yield all the uninstallation paths for dist based on RECORD-without-.py[co]

Yield paths to all the files in RECORD. For each .py file in RECORD, add
the .pyc and .pyo in the same directory.

UninstallPathSet.add() takes care of the __pycache__ .py[co].

If RECORD is not found, raises UninstallationError,
with possible information from the INSTALLER file.

https://packaging.python.org/specifications/recording-installed-packages/

Definition at line 55 of file req_uninstall.py.

def uninstallation_paths(dist: BaseDistribution) -> Generator[str, None, None]:
    """
    Yield all the uninstallation paths for dist based on RECORD-without-.py[co]
 
    Yield paths to all the files in RECORD. For each .py file in RECORD, add
    the .pyc and .pyo in the same directory.
 
    UninstallPathSet.add() takes care of the __pycache__ .py[co].
 
    If RECORD is not found, raises UninstallationError,
    with possible information from the INSTALLER file.
 
    https://packaging.python.org/specifications/recording-installed-packages/
    """
    location = dist.location
    assert location is not None, "not installed"
 
    entries = dist.iter_declared_entries()
    if entries is None:
        msg = "Cannot uninstall {dist}, RECORD file not found.".format(dist=dist)
        installer = dist.installer
        if not installer or installer == "pip":
            dep = "{}=={}".format(dist.raw_name, dist.version)
            msg += (
                " You might be able to recover from this via: "
                "'pip install --force-reinstall --no-deps {}'.".format(dep)
            )
        else:
            msg += " Hint: The package was installed by {}.".format(installer)
        raise UninstallationError(msg)
 
    for entry in entries:
        path = os.path.join(location, entry)
        yield path
        if path.endswith(".py"):
            dn, fn = os.path.split(path)
            base = fn[:-3]
            path = os.path.join(dn, base + ".pyc")
            yield path
            path = os.path.join(dn, base + ".pyo")
            yield path
 
 

References i.

Referenced by UninstallPathSet.from_dist().

Here is the caller graph for this function:

Variable Documentation

logger

logger = getLogger(__name__)

Definition at line 18 of file req_uninstall.py.