Data Structures
class	_ReqExtras

class	ContextualVersionConflict

class	DefaultProvider

class	DistInfoDistribution

class	Distribution

class	DistributionNotFound

class	EggInfoDistribution

class	EggMetadata

class	EggProvider

class	EmptyProvider

class	EntryPoint

class	Environment

class	ExtractionError

class	FileMetadata

class	IMetadataProvider

class	IResourceProvider

class	MemoizedZipManifests

class	NoDists

class	NullProvider

class	PathMetadata

class	PEP440Warning

class	PkgResourcesDeprecationWarning

class	Requirement

class	RequirementParseError

class	ResolutionError

class	ResourceManager

class	UnknownExtra

class	VersionConflict

class	WorkingSet

class	ZipManifests

class	ZipProvider

Functions
	_declare_state (vartype, **kw)

	__getstate__ ()

	__setstate__ (state)

	_sget_dict (val)

	_sset_dict (key, ob, state)

	_sget_object (val)

	_sset_object (key, ob, state)

	get_supported_platform ()

	register_loader_type (loader_type, provider_factory)

	get_provider (moduleOrReq)

	_macos_vers (_cache=[])

	_macos_arch (machine)

	get_build_platform ()

	compatible_platforms (provided, required)

	run_script (dist_spec, script_name)

	get_distribution (dist)

	load_entry_point (dist, group, name)

	get_entry_map (dist, group=None)

	get_entry_info (dist, group, name)

	get_default_cache ()

	safe_name (name)

	safe_version (version)

	_forgiving_version (version)

	_safe_segment (segment)

	safe_extra (extra)

	to_filename (name)

	invalid_marker (text)

	evaluate_marker (text, extra=None)

	_parents (path)

	register_finder (importer_type, distribution_finder)

	find_distributions (path_item, only=False)

	find_eggs_in_zip (importer, path_item, only=False)

	find_nothing (importer, path_item, only=False)

	find_on_path (importer, path_item, only=False)

	dist_factory (path_item, entry, only)

	safe_listdir (path)

	distributions_from_metadata (path)

	non_empty_lines (path)

	resolve_egg_link (path)

	register_namespace_handler (importer_type, namespace_handler)

	_handle_ns (packageName, path_item)

	_rebuild_mod_path (orig_path, package_name, module)

	declare_namespace (packageName)

	fixup_namespace_packages (path_item, parent=None)

	file_ns_handler (importer, path_item, packageName, module)

	null_ns_handler (importer, path_item, packageName, module)

	normalize_path (filename)

	_cygwin_patch (filename)

	_normalize_cached (filename, _cache={})

	_is_egg_path (path)

	_is_zip_egg (path)

	_is_unpacked_egg (path)

	_set_parent_ns (packageName)

	_version_from_file (lines)

	issue_warning (args, *kw)

	parse_requirements (strs)

	_always_object (classes)

	_find_adapter (registry, ob)

	ensure_directory (path)

	_bypass_ensure_directory (path)

	split_sections (s)

	_mkstemp (args, *kw)

	_call_aside (f, args, *kwargs)

	_initialize (g=globals())

	_initialize_master_working_set ()

Variables
	FileExistsError = OSError

bool	WRITE_SUPPORT = True

	importlib_machinery = None

	require = None

	working_set = None

	add_activation_listener = None

	resources_stream = None

	cleanup_resources = None

	resource_dir = None

	resource_stream = None

	set_extraction_path = None

	resource_isdir = None

	resource_string = None

	iter_entry_points = None

	resource_listdir = None

	resource_filename = None

	resource_exists = None

	_distribution_finders = None

	_namespace_handlers = None

	_namespace_packages = None

	stacklevel

	_PEP440_FALLBACK = re.compile(r"^v?(?P<safe>(?:[0-9]+!)?[0-9]+(?:\.[0-9]+)*)", re.I)

	parse_version = packaging.version.Version

dict	_state_vars = {}

None	_sget_none = lambda *args

dict	_provider_factories = {}

str	PY_MAJOR = '{}.{}'.format(*sys.version_info)

int	EGG_DIST = 3

int	BINARY_DIST = 2

int	SOURCE_DIST = 1

int	CHECKOUT_DIST = 0

int	DEVELOP_DIST = -1

	macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")

	darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")

	get_platform = get_build_platform

	run_main = run_script

	AvailableDistributions = Environment

	empty_provider = EmptyProvider()

	MODULE = re.compile(r"\w+(\.\w+)*$").match

	EGG_NAME

dict	_distributionImpl

	category

	PEP440Warning

	append

Detailed Description

Package resource API
--------------------

A resource is a logical file contained within a package, or a logical
subdirectory thereof.  The package resource API expects resource names
to have their path parts separated with ``/``, *not* whatever the local
path separator is.  Do not use os.path operations to manipulate resource
names being passed into the API.

The package resource API is designed to work with normal filesystem packages,
.egg files, and unpacked .egg files.  It can also work in a limited way with
.zip files and with custom PEP 302 loaders that support the ``get_data()``
method.

This module is deprecated. Users are directed to :mod:`importlib.resources`,
:mod:`importlib.metadata` and :pypi:`packaging` instead.

Function Documentation

◆ getstate()

__getstate__ ( )

Definition at line 147 of file __init__.py.

def __getstate__():
    state = {}
    g = globals()
    for k, v in _state_vars.items():
        state[k] = g['_sget_' + v](g[k])
    return state
 
 

References i.

◆ setstate()

__setstate__ ( state )

Definition at line 155 of file __init__.py.

def __setstate__(state):
    g = globals()
    for k, v in state.items():
        g['_sset_' + _state_vars[k]](k, g[k], v)
    return state
 
 

References i.

◆ _always_object()

_always_object ( classes )

protected

Ensure object appears in the mro even
for old-style classes.

Definition at line 3219 of file __init__.py.

def _always_object(classes):
    """
    Ensure object appears in the mro even
    for old-style classes.
    """
    if object not in classes:
        return classes + (object,)
    return classes
 
 

◆ _bypass_ensure_directory()

_bypass_ensure_directory ( path )

protected

Sandbox-bypassing version of ensure_directory()

Definition at line 3243 of file __init__.py.

def _bypass_ensure_directory(path):
    """Sandbox-bypassing version of ensure_directory()"""
    if not WRITE_SUPPORT:
        raise IOError('"os.mkdir" not supported on this platform.')
    dirname, filename = split(path)
    if dirname and filename and not isdir(dirname):
        _bypass_ensure_directory(dirname)
        try:
            mkdir(dirname, 0o755)
        except FileExistsError:
            pass
 
 

◆ _call_aside()

_call_aside	(		f,
		*	args,
		**	kwargs
	)

protected

Definition at line 3301 of file __init__.py.

def _call_aside(f, *args, **kwargs):
    f(*args, **kwargs)
    return f
 
 
@_call_aside

◆ _cygwin_patch()

_cygwin_patch ( filename )

protected

Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
symlink components. Using
os.path.abspath() works around this limitation. A fix in os.getcwd()
would probably better, in Cygwin even more so, except
that this seems to be by design...

Definition at line 2416 of file __init__.py.

def _cygwin_patch(filename):  # pragma: nocover
    """
    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
    symlink components. Using
    os.path.abspath() works around this limitation. A fix in os.getcwd()
    would probably better, in Cygwin even more so, except
    that this seems to be by design...
    """
    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
 
 

◆ _declare_state()

_declare_state	(		vartype,
		**	kw
	)

protected

Definition at line 142 of file __init__.py.

def _declare_state(vartype, **kw):
    globals().update(kw)
    _state_vars.update(dict.fromkeys(kw, vartype))
 
 

References i.

◆ _find_adapter()

_find_adapter	(	registry,
		ob
	)

protected

Return an adapter factory for `ob` from `registry`

Definition at line 3229 of file __init__.py.

def _find_adapter(registry, ob):
    """Return an adapter factory for `ob` from `registry`"""
    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
    for t in types:
        if t in registry:
            return registry[t]
 
 

Referenced by pip._vendor.pkg_resources.get_provider().

Here is the caller graph for this function:

◆ _forgiving_version()

_forgiving_version ( version )

protected

Fallback when ``safe_version`` is not safe enough
>>> parse_version(_forgiving_version('0.23ubuntu1'))
<Version('0.23.dev0+sanitized.ubuntu1')>
>>> parse_version(_forgiving_version('0.23-'))
<Version('0.23.dev0+sanitized')>
>>> parse_version(_forgiving_version('0.-_'))
<Version('0.dev0+sanitized')>
>>> parse_version(_forgiving_version('42.+?1'))
<Version('42.dev0+sanitized.1')>
>>> parse_version(_forgiving_version('hello world'))
<Version('0.dev0+sanitized.hello.world')>

Definition at line 1404 of file __init__.py.

def _forgiving_version(version):
    """Fallback when ``safe_version`` is not safe enough
    >>> parse_version(_forgiving_version('0.23ubuntu1'))
    <Version('0.23.dev0+sanitized.ubuntu1')>
    >>> parse_version(_forgiving_version('0.23-'))
    <Version('0.23.dev0+sanitized')>
    >>> parse_version(_forgiving_version('0.-_'))
    <Version('0.dev0+sanitized')>
    >>> parse_version(_forgiving_version('42.+?1'))
    <Version('42.dev0+sanitized.1')>
    >>> parse_version(_forgiving_version('hello world'))
    <Version('0.dev0+sanitized.hello.world')>
    """
    version = version.replace(' ', '.')
    match = _PEP440_FALLBACK.search(version)
    if match:
        safe = match["safe"]
        rest = version[len(safe):]
    else:
        safe = "0"
        rest = version
    local = f"sanitized.{_safe_segment(rest)}".strip(".")
    return f"{safe}.dev0+{local}"
 
 

◆ _handle_ns()

_handle_ns	(	packageName,
		path_item
	)

protected

Ensure that named package includes a subpath of path_item (if needed)

Definition at line 2258 of file __init__.py.

def _handle_ns(packageName, path_item):
    """Ensure that named package includes a subpath of path_item (if needed)"""
 
    importer = get_importer(path_item)
    if importer is None:
        return None
 
    # use find_spec (PEP 451) and fall-back to find_module (PEP 302)
    try:
        spec = importer.find_spec(packageName)
    except AttributeError:
        # capture warnings due to #1111
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            loader = importer.find_module(packageName)
    else:
        loader = spec.loader if spec else None
 
    if loader is None:
        return None
    module = sys.modules.get(packageName)
    if module is None:
        module = sys.modules[packageName] = types.ModuleType(packageName)
        module.__path__ = []
        _set_parent_ns(packageName)
    elif not hasattr(module, '__path__'):
        raise TypeError("Not a package:", packageName)
    handler = _find_adapter(_namespace_handlers, importer)
    subpath = handler(importer, path_item, packageName, module)
    if subpath is not None:
        path = module.__path__
        path.append(subpath)
        importlib.import_module(packageName)
        _rebuild_mod_path(path, packageName, module)
    return subpath
 
 

◆ _initialize()

_initialize ( g = globals() )

protected

Definition at line 3307 of file __init__.py.

def _initialize(g=globals()):
    "Set up global resource manager (deliberately not state-saved)"
    manager = ResourceManager()
    g['_manager'] = manager
    g.update(
        (name, getattr(manager, name))
        for name in dir(manager)
        if not name.startswith('_')
    )
 
 

◆ _initialize_master_working_set()

_initialize_master_working_set ( )

protected

Prepare the master working set and make the ``require()``
API available.

This function has explicit effects on the global state
of pkg_resources. It is intended to be invoked once at
the initialization of this module.

Invocation by other packages is unsupported and done
at their own risk.

Definition at line 3328 of file __init__.py.

def _initialize_master_working_set():
    """
    Prepare the master working set and make the ``require()``
    API available.
 
    This function has explicit effects on the global state
    of pkg_resources. It is intended to be invoked once at
    the initialization of this module.
 
    Invocation by other packages is unsupported and done
    at their own risk.
    """
    working_set = WorkingSet._build_master()
    _declare_state('object', working_set=working_set)
 
    require = working_set.require
    iter_entry_points = working_set.iter_entry_points
    add_activation_listener = working_set.subscribe
    run_script = working_set.run_script
    # backward compatibility
    run_main = run_script
    # Activate all distributions already on sys.path with replace=False and
    # ensure that all distributions added to the working set in the future
    # (e.g. by calling ``require()``) will get activated as well,
    # with higher priority (replace=True).
    tuple(dist.activate(replace=False) for dist in working_set)
    add_activation_listener(
        lambda dist: dist.activate(replace=True),
        existing=False,
    )
    working_set.entries = []
    # match order
    list(map(working_set.add_entry, sys.path))
    globals().update(locals())

◆ _is_egg_path()

_is_egg_path ( path )

protected

Determine if given path appears to be an egg.

Definition at line 2435 of file __init__.py.

def _is_egg_path(path):
    """
    Determine if given path appears to be an egg.
    """
    return _is_zip_egg(path) or _is_unpacked_egg(path)
 
 

◆ _is_unpacked_egg()

_is_unpacked_egg ( path )

protected

Determine if given path appears to be an unpacked egg.

Definition at line 2450 of file __init__.py.

def _is_unpacked_egg(path):
    """
    Determine if given path appears to be an unpacked egg.
    """
    return path.lower().endswith('.egg') and os.path.isfile(
        os.path.join(path, 'EGG-INFO', 'PKG-INFO')
    )
 
 

◆ _is_zip_egg()

_is_zip_egg ( path )

protected

Definition at line 2442 of file __init__.py.

def _is_zip_egg(path):
    return (
        path.lower().endswith('.egg')
        and os.path.isfile(path)
        and zipfile.is_zipfile(path)
    )
 
 

◆ _macos_arch()

_macos_arch ( machine )

protected

Definition at line 426 of file __init__.py.

def _macos_arch(machine):
    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)

Referenced by pip._vendor.pkg_resources.get_build_platform().

Here is the caller graph for this function:

◆ _macos_vers()

_macos_vers ( _cache = [] )

protected

Definition at line 410 of file __init__.py.

def _macos_vers(_cache=[]):
    if not _cache:
        version = platform.mac_ver()[0]
        # fallback for MacPorts
        if version == '':
            plist = '/System/Library/CoreServices/SystemVersion.plist'
            if os.path.exists(plist):
                if hasattr(plistlib, 'readPlist'):
                    plist_content = plistlib.readPlist(plist)
                    if 'ProductVersion' in plist_content:
                        version = plist_content['ProductVersion']
 
        _cache.append(version.split('.'))
    return _cache[0]
 
 

References i.

Referenced by pip._vendor.pkg_resources.get_build_platform(), and pip._vendor.pkg_resources.get_supported_platform().

Here is the caller graph for this function:

◆ _mkstemp()

_mkstemp	(	*	args,
		**	kw
	)

protected

Definition at line 3282 of file __init__.py.

def _mkstemp(*args, **kw):
    old_open = os.open
    try:
        # temporarily bypass sandboxing
        os.open = os_open
        return tempfile.mkstemp(*args, **kw)
    finally:
        # and then put it back
        os.open = old_open
 
 
# Silence the PEP440Warning by default, so that end users don't get hit by it
# randomly just because they use pkg_resources. We want to append the rule
# because we want earlier uses of filterwarnings to take precedence over this
# one.

◆ _normalize_cached()

_normalize_cached	(	filename,
		_cache = `{}`
	)

protected

Definition at line 2427 of file __init__.py.

def _normalize_cached(filename, _cache={}):
    try:
        return _cache[filename]
    except KeyError:
        _cache[filename] = result = normalize_path(filename)
        return result
 
 

◆ _parents()

_parents ( path )

protected

yield all parents of path including path

Definition at line 1680 of file __init__.py.

def _parents(path):
    """
    yield all parents of path including path
    """
    last = None
    while path != last:
        yield path
        last = path
        path, _ = os.path.split(path)
 
 

◆ _rebuild_mod_path()

_rebuild_mod_path	(	orig_path,
		package_name,
		module
	)

protected

Rebuild module.__path__ ensuring that all entries are ordered
corresponding to their sys.path order

Definition at line 2295 of file __init__.py.

def _rebuild_mod_path(orig_path, package_name, module):
    """
    Rebuild module.__path__ ensuring that all entries are ordered
    corresponding to their sys.path order
    """
    sys_path = [_normalize_cached(p) for p in sys.path]
 
    def safe_sys_path_index(entry):
        """
        Workaround for #520 and #513.
        """
        try:
            return sys_path.index(entry)
        except ValueError:
            return float('inf')
 
    def position_in_sys_path(path):
        """
        Return the ordinal of the path based on its position in sys.path
        """
        path_parts = path.split(os.sep)
        module_parts = package_name.count('.') + 1
        parts = path_parts[:-module_parts]
        return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
 
    new_path = sorted(orig_path, key=position_in_sys_path)
    new_path = [_normalize_cached(p) for p in new_path]
 
    if isinstance(module.__path__, list):
        module.__path__[:] = new_path
    else:
        module.__path__ = new_path
 
 

◆ _safe_segment()

_safe_segment ( segment )

protected

Convert an arbitrary string into a safe segment

Definition at line 1429 of file __init__.py.

def _safe_segment(segment):
    """Convert an arbitrary string into a safe segment"""
    segment = re.sub('[^A-Za-z0-9.]+', '-', segment)
    segment = re.sub('-[^A-Za-z0-9]+', '-', segment)
    return re.sub(r'\.[^A-Za-z0-9]+', '.', segment).strip(".-")
 
 

◆ _set_parent_ns()

_set_parent_ns ( packageName )

protected

Definition at line 2459 of file __init__.py.

def _set_parent_ns(packageName):
    parts = packageName.split('.')
    name = parts.pop()
    if parts:
        parent = '.'.join(parts)
        setattr(sys.modules[parent], name, sys.modules[packageName])
 
 

◆ _sget_dict()

_sget_dict ( val )

protected

Definition at line 162 of file __init__.py.

def _sget_dict(val):
    return val.copy()

References i.

◆ _sget_object()

_sget_object ( val )

protected

Definition at line 171 of file __init__.py.

def _sget_object(val):
    return val.__getstate__()

References i.

◆ _sset_dict()

_sset_dict	(	key,
		ob,
		state
	)

protected

Definition at line 166 of file __init__.py.

def _sset_dict(key, ob, state):
    ob.clear()
    ob.update(state)
 
 

References i.

◆ _sset_object()

_sset_object	(	key,
		ob,
		state
	)

protected

Definition at line 175 of file __init__.py.

def _sset_object(key, ob, state):
    ob.__setstate__(state)

References i.

◆ _version_from_file()

_version_from_file ( lines )

protected

Given an iterable of lines from a Metadata file, return
the value of the Version field, if present, or None otherwise.

Definition at line 2614 of file __init__.py.

def _version_from_file(lines):
    """
    Given an iterable of lines from a Metadata file, return
    the value of the Version field, if present, or None otherwise.
    """
 
    def is_version_line(line):
        return line.lower().startswith('version:')
 
    version_lines = filter(is_version_line, lines)
    line = next(iter(version_lines), '')
    _, _, value = line.partition(':')
    return safe_version(value.strip()) or None
 
 

◆ compatible_platforms()

compatible_platforms	(	provided,
		required
	)

Can code for the `provided` platform run on the `required` platform?

Returns true if either platform is ``None``, or the platforms are equal.

XXX Needs compatibility checks for Linux and other unixy OSes.

Definition at line 461 of file __init__.py.

def compatible_platforms(provided, required):
    """Can code for the `provided` platform run on the `required` platform?
 
    Returns true if either platform is ``None``, or the platforms are equal.
 
    XXX Needs compatibility checks for Linux and other unixy OSes.
    """
    if provided is None or required is None or provided == required:
        # easy case
        return True
 
    # macOS special cases
    reqMac = macosVersionString.match(required)
    if reqMac:
        provMac = macosVersionString.match(provided)
 
        # is this a Mac package?
        if not provMac:
            # this is backwards compatibility for packages built before
            # setuptools 0.6. All packages built after this point will
            # use the new macOS designation.
            provDarwin = darwinVersionString.match(provided)
            if provDarwin:
                dversion = int(provDarwin.group(1))
                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
                if (
                    dversion == 7
                    and macosversion >= "10.3"
                    or dversion == 8
                    and macosversion >= "10.4"
                ):
                    return True
            # egg isn't macOS or legacy darwin
            return False
 
        # are they the same major version and machine type?
        if provMac.group(1) != reqMac.group(1) or provMac.group(3) != reqMac.group(3):
            return False
 
        # is the required OS major update >= the provided one?
        if int(provMac.group(2)) > int(reqMac.group(2)):
            return False
 
        return True
 
    # XXX Linux and other platforms' special cases should go here
    return False
 
 

References i.

◆ declare_namespace()

declare_namespace ( packageName )

Declare that package 'packageName' is a namespace package

Definition at line 2329 of file __init__.py.

def declare_namespace(packageName):
    """Declare that package 'packageName' is a namespace package"""
 
    msg = (
        f"Deprecated call to `pkg_resources.declare_namespace({packageName!r})`.\n"
        "Implementing implicit namespace packages (as specified in PEP 420) "
        "is preferred to `pkg_resources.declare_namespace`. "
        "See https://setuptools.pypa.io/en/latest/references/"
        "keywords.html#keyword-namespace-packages"
    )
    warnings.warn(msg, DeprecationWarning, stacklevel=2)
 
    _imp.acquire_lock()
    try:
        if packageName in _namespace_packages:
            return
 
        path = sys.path
        parent, _, _ = packageName.rpartition('.')
 
        if parent:
            declare_namespace(parent)
            if parent not in _namespace_packages:
                __import__(parent)
            try:
                path = sys.modules[parent].__path__
            except AttributeError as e:
                raise TypeError("Not a package:", parent) from e
 
        # Track what packages are namespaces, so when new path items are added,
        # they can be updated
        _namespace_packages.setdefault(parent or None, []).append(packageName)
        _namespace_packages.setdefault(packageName, [])
 
        for path_item in path:
            # Ensure all the parent's path items are reflected in the child,
            # if they apply
            _handle_ns(packageName, path_item)
 
    finally:
        _imp.release_lock()
 
 

◆ dist_factory()

dist_factory	(	path_item,
		entry,
		only
	)

Return a dist_factory for the given entry.

Definition at line 2138 of file __init__.py.

def dist_factory(path_item, entry, only):
    """Return a dist_factory for the given entry."""
    lower = entry.lower()
    is_egg_info = lower.endswith('.egg-info')
    is_dist_info = lower.endswith('.dist-info') and os.path.isdir(
        os.path.join(path_item, entry)
    )
    is_meta = is_egg_info or is_dist_info
    return (
        distributions_from_metadata
        if is_meta
        else find_distributions
        if not only and _is_egg_path(entry)
        else resolve_egg_link
        if not only and lower.endswith('.egg-link')
        else NoDists()
    )
 
 

◆ distributions_from_metadata()

distributions_from_metadata ( path )

Definition at line 2189 of file __init__.py.

def distributions_from_metadata(path):
    root = os.path.dirname(path)
    if os.path.isdir(path):
        if len(os.listdir(path)) == 0:
            # empty metadata dir; skip
            return
        metadata = PathMetadata(root, path)
    else:
        metadata = FileMetadata(path)
    entry = os.path.basename(path)
    yield Distribution.from_location(
        root,
        entry,
        metadata,
        precedence=DEVELOP_DIST,
    )
 
 

◆ ensure_directory()

ensure_directory ( path )

Ensure that the parent directory of `path` exists

Definition at line 3237 of file __init__.py.

def ensure_directory(path):
    """Ensure that the parent directory of `path` exists"""
    dirname = os.path.dirname(path)
    os.makedirs(dirname, exist_ok=True)
 
 

◆ evaluate_marker()

evaluate_marker	(	text,
		extra = `None`
	)

Evaluate a PEP 508 environment marker.
Return a boolean indicating the marker result in this environment.
Raise SyntaxError if marker is invalid.

This implementation uses the 'pyparsing' module.

Definition at line 1467 of file __init__.py.

def evaluate_marker(text, extra=None):
    """
    Evaluate a PEP 508 environment marker.
    Return a boolean indicating the marker result in this environment.
    Raise SyntaxError if marker is invalid.
 
    This implementation uses the 'pyparsing' module.
    """
    try:
        marker = packaging.markers.Marker(text)
        return marker.evaluate()
    except packaging.markers.InvalidMarker as e:
        raise SyntaxError(e) from e
 
 

◆ file_ns_handler()

file_ns_handler	(	importer,
		path_item,
		packageName,
		module
	)

Compute an ns-package subpath for a filesystem or zipfile importer

Definition at line 2384 of file __init__.py.

def file_ns_handler(importer, path_item, packageName, module):
    """Compute an ns-package subpath for a filesystem or zipfile importer"""
 
    subpath = os.path.join(path_item, packageName.split('.')[-1])
    normalized = _normalize_cached(subpath)
    for item in module.__path__:
        if _normalize_cached(item) == normalized:
            break
    else:
        # Only return the path if it's not already there
        return subpath
 
 

◆ find_distributions()

find_distributions	(	path_item,
		only = `False`
	)

Yield distributions accessible via `path_item`

Definition at line 2073 of file __init__.py.

def find_distributions(path_item, only=False):
    """Yield distributions accessible via `path_item`"""
    importer = get_importer(path_item)
    finder = _find_adapter(_distribution_finders, importer)
    return finder(importer, path_item, only)
 
 

◆ find_eggs_in_zip()

find_eggs_in_zip	(	importer,
		path_item,
		only = `False`
	)

Find eggs in zip files; possibly multiple nested eggs.

Definition at line 2080 of file __init__.py.

def find_eggs_in_zip(importer, path_item, only=False):
    """
    Find eggs in zip files; possibly multiple nested eggs.
    """
    if importer.archive.endswith('.whl'):
        # wheels are not supported with this finder
        # they don't have PKG-INFO metadata, and won't ever contain eggs
        return
    metadata = EggMetadata(importer)
    if metadata.has_metadata('PKG-INFO'):
        yield Distribution.from_filename(path_item, metadata=metadata)
    if only:
        # don't yield nested distros
        return
    for subitem in metadata.resource_listdir(''):
        if _is_egg_path(subitem):
            subpath = os.path.join(path_item, subitem)
            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
            for dist in dists:
                yield dist
        elif subitem.lower().endswith(('.dist-info', '.egg-info')):
            subpath = os.path.join(path_item, subitem)
            submeta = EggMetadata(zipimport.zipimporter(subpath))
            submeta.egg_info = subpath
            yield Distribution.from_location(path_item, subitem, submeta)
 
 

◆ find_nothing()

find_nothing	(	importer,
		path_item,
		only = `False`
	)

Definition at line 2110 of file __init__.py.

def find_nothing(importer, path_item, only=False):
    return ()

◆ find_on_path()

find_on_path	(	importer,
		path_item,
		only = `False`
	)

Yield distributions accessible on a sys.path directory

Definition at line 2117 of file __init__.py.

def find_on_path(importer, path_item, only=False):
    """Yield distributions accessible on a sys.path directory"""
    path_item = _normalize_cached(path_item)
 
    if _is_unpacked_egg(path_item):
        yield Distribution.from_filename(
            path_item,
            metadata=PathMetadata(path_item, os.path.join(path_item, 'EGG-INFO')),
        )
        return
 
    entries = (os.path.join(path_item, child) for child in safe_listdir(path_item))
 
    # scan for .egg and .egg-info in directory
    for entry in sorted(entries):
        fullpath = os.path.join(path_item, entry)
        factory = dist_factory(path_item, entry, only)
        for dist in factory(fullpath):
            yield dist
 
 

◆ fixup_namespace_packages()

fixup_namespace_packages	(	path_item,
		parent = `None`
	)

Ensure that previously-declared namespace packages include path_item

Definition at line 2372 of file __init__.py.

def fixup_namespace_packages(path_item, parent=None):
    """Ensure that previously-declared namespace packages include path_item"""
    _imp.acquire_lock()
    try:
        for package in _namespace_packages.get(parent, ()):
            subpath = _handle_ns(package, path_item)
            if subpath:
                fixup_namespace_packages(subpath, package)
    finally:
        _imp.release_lock()
 
 

◆ get_build_platform()

get_build_platform ( )

Return this platform's string for platform-specific distributions

XXX Currently this is the same as ``distutils.util.get_platform()``, but it
needs some hacks for Linux and macOS.

Definition at line 430 of file __init__.py.

def get_build_platform():
    """Return this platform's string for platform-specific distributions
 
    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
    needs some hacks for Linux and macOS.
    """
    from sysconfig import get_platform
 
    plat = get_platform()
    if sys.platform == "darwin" and not plat.startswith('macosx-'):
        try:
            version = _macos_vers()
            machine = os.uname()[4].replace(" ", "_")
            return "macosx-%d.%d-%s" % (
                int(version[0]),
                int(version[1]),
                _macos_arch(machine),
            )
        except ValueError:
            # if someone is running a non-Mac darwin system, this will fall
            # through to the default implementation
            pass
    return plat
 
 

References pip._vendor.pkg_resources._macos_arch(), pip._vendor.pkg_resources._macos_vers(), pip._vendor.pkg_resources.get_platform, and i.

Referenced by pip._vendor.pkg_resources.get_supported_platform().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_default_cache()

get_default_cache ( )

Return the ``PYTHON_EGG_CACHE`` environment variable
or a platform-relevant user cache dir for an app
named "Python-Eggs".

Definition at line 1373 of file __init__.py.

def get_default_cache():
    """
    Return the ``PYTHON_EGG_CACHE`` environment variable
    or a platform-relevant user cache dir for an app
    named "Python-Eggs".
    """
    return os.environ.get('PYTHON_EGG_CACHE') or platformdirs.user_cache_dir(
        appname='Python-Eggs'
    )
 
 

◆ get_distribution()

get_distribution ( dist )

Return a current distribution object for a Requirement or string

Definition at line 523 of file __init__.py.

def get_distribution(dist):
    """Return a current distribution object for a Requirement or string"""
    if isinstance(dist, str):
        dist = Requirement.parse(dist)
    if isinstance(dist, Requirement):
        dist = get_provider(dist)
    if not isinstance(dist, Distribution):
        raise TypeError("Expected string, Requirement, or Distribution", dist)
    return dist
 
 

References pip._vendor.pkg_resources.get_provider(), and i.

Here is the call graph for this function:

◆ get_entry_info()

get_entry_info	(	dist,
		group,
		name
	)

Return the EntryPoint object for `group`+`name`, or ``None``

Definition at line 544 of file __init__.py.

def get_entry_info(dist, group, name):
    """Return the EntryPoint object for `group`+`name`, or ``None``"""
    return get_distribution(dist).get_entry_info(group, name)
 
 

◆ get_entry_map()

get_entry_map	(	dist,
		group = `None`
	)

Return the entry point map for `group`, or the full entry map

Definition at line 539 of file __init__.py.

def get_entry_map(dist, group=None):
    """Return the entry point map for `group`, or the full entry map"""
    return get_distribution(dist).get_entry_map(group)
 
 

◆ get_provider()

get_provider ( moduleOrReq )

Return an IResourceProvider for the named module or requirement

Definition at line 397 of file __init__.py.

def get_provider(moduleOrReq):
    """Return an IResourceProvider for the named module or requirement"""
    if isinstance(moduleOrReq, Requirement):
        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
    try:
        module = sys.modules[moduleOrReq]
    except KeyError:
        __import__(moduleOrReq)
        module = sys.modules[moduleOrReq]
    loader = getattr(module, '__loader__', None)
    return _find_adapter(_provider_factories, loader)(module)
 
 

References pip._vendor.pkg_resources._find_adapter(), i, and pip._vendor.pkg_resources.require.

Referenced by pip._vendor.pkg_resources.get_distribution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_supported_platform()

get_supported_platform ( )

Return this platform's maximum compatible version.

distutils.util.get_platform() normally reports the minimum version
of macOS that would be required to *use* extensions produced by
distutils.  But what we want when checking compatibility is to know the
version of macOS that we are *running*.  To allow usage of packages that
explicitly require a newer version of macOS, we must also know the
current version of the OS.

If this condition occurs for any other platform with a version in its
platform strings, this function should be extended accordingly.

Definition at line 182 of file __init__.py.

def get_supported_platform():
    """Return this platform's maximum compatible version.
 
    distutils.util.get_platform() normally reports the minimum version
    of macOS that would be required to *use* extensions produced by
    distutils.  But what we want when checking compatibility is to know the
    version of macOS that we are *running*.  To allow usage of packages that
    explicitly require a newer version of macOS, we must also know the
    current version of the OS.
 
    If this condition occurs for any other platform with a version in its
    platform strings, this function should be extended accordingly.
    """
    plat = get_build_platform()
    m = macosVersionString.match(plat)
    if m is not None and sys.platform == "darwin":
        try:
            plat = 'macosx-%s-%s' % ('.'.join(_macos_vers()[:2]), m.group(3))
        except ValueError:
            # not macOS
            pass
    return plat
 
 

References pip._vendor.pkg_resources._macos_vers(), pip._vendor.pkg_resources.get_build_platform(), and i.

Here is the call graph for this function:

◆ invalid_marker()

invalid_marker ( text )

Validate text as a PEP 508 environment marker; return an exception
if invalid or False otherwise.

Definition at line 1453 of file __init__.py.

def invalid_marker(text):
    """
    Validate text as a PEP 508 environment marker; return an exception
    if invalid or False otherwise.
    """
    try:
        evaluate_marker(text)
    except SyntaxError as e:
        e.filename = None
        e.lineno = None
        return e
    return False
 
 

◆ issue_warning()

issue_warning	(	*	args,
		**	kw
	)

Definition at line 3145 of file __init__.py.

def issue_warning(*args, **kw):
    level = 1
    g = globals()
    try:
        # find the first stack frame that is *not* code in
        # the pkg_resources module, to use for the warning
        while sys._getframe(level).f_globals is g:
            level += 1
    except ValueError:
        pass
    warnings.warn(stacklevel=level + 1, *args, **kw)
 
 

◆ load_entry_point()

load_entry_point	(	dist,
		group,
		name
	)

Return `name` entry point of `group` for `dist` or raise ImportError

Definition at line 534 of file __init__.py.

def load_entry_point(dist, group, name):
    """Return `name` entry point of `group` for `dist` or raise ImportError"""
    return get_distribution(dist).load_entry_point(group, name)
 
 

◆ non_empty_lines()

non_empty_lines ( path )

Yield non-empty lines from file at path

Definition at line 2207 of file __init__.py.

def non_empty_lines(path):
    """
    Yield non-empty lines from file at path
    """
    with open(path) as f:
        for line in f:
            line = line.strip()
            if line:
                yield line
 
 

◆ normalize_path()

normalize_path ( filename )

Normalize a file/dir name for comparison purposes

Definition at line 2411 of file __init__.py.

def normalize_path(filename):
    """Normalize a file/dir name for comparison purposes"""
    return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename))))
 
 

◆ null_ns_handler()

null_ns_handler	(	importer,
		path_item,
		packageName,
		module
	)

Definition at line 2404 of file __init__.py.

def null_ns_handler(importer, path_item, packageName, module):
    return None

◆ parse_requirements()

parse_requirements ( strs )

Yield ``Requirement`` objects for each specification in `strs`.

`strs` must be a string, or a (possibly-nested) iterable thereof.

Definition at line 3158 of file __init__.py.

def parse_requirements(strs):
    """
    Yield ``Requirement`` objects for each specification in `strs`.
 
    `strs` must be a string, or a (possibly-nested) iterable thereof.
    """
    return map(Requirement, join_continuation(map(drop_comment, yield_lines(strs))))
 
 

◆ register_finder()

register_finder	(	importer_type,
		distribution_finder
	)

Register `distribution_finder` to find distributions in sys.path items

`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
handler), and `distribution_finder` is a callable that, passed a path
item and the importer instance, yields ``Distribution`` instances found on
that path item.  See ``pkg_resources.find_on_path`` for an example.

Definition at line 2063 of file __init__.py.

def register_finder(importer_type, distribution_finder):
    """Register `distribution_finder` to find distributions in sys.path items
 
    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
    handler), and `distribution_finder` is a callable that, passed a path
    item and the importer instance, yields ``Distribution`` instances found on
    that path item.  See ``pkg_resources.find_on_path`` for an example."""
    _distribution_finders[importer_type] = distribution_finder
 
 

◆ register_loader_type()

register_loader_type	(	loader_type,
		provider_factory
	)

Register `provider_factory` to make providers for `loader_type`

`loader_type` is the type or class of a PEP 302 ``module.__loader__``,
and `provider_factory` is a function that, passed a *module* object,
returns an ``IResourceProvider`` for that module.

Definition at line 387 of file __init__.py.

def register_loader_type(loader_type, provider_factory):
    """Register `provider_factory` to make providers for `loader_type`
 
    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
    and `provider_factory` is a function that, passed a *module* object,
    returns an ``IResourceProvider`` for that module.
    """
    _provider_factories[loader_type] = provider_factory
 
 

◆ register_namespace_handler()

register_namespace_handler	(	importer_type,
		namespace_handler
	)

Register `namespace_handler` to declare namespace packages

`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
handler), and `namespace_handler` is a callable like this::

    def namespace_handler(importer, path_entry, moduleName, module):
        # return a path_entry to use for child packages

Namespace handlers are only called if the importer object has already
agreed that it can handle the relevant path item, and they should only
return a subpath if the module __path__ does not already contain an
equivalent subpath.  For an example namespace handler, see
``pkg_resources.file_ns_handler``.

Definition at line 2240 of file __init__.py.

def register_namespace_handler(importer_type, namespace_handler):
    """Register `namespace_handler` to declare namespace packages
 
    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
    handler), and `namespace_handler` is a callable like this::
 
        def namespace_handler(importer, path_entry, moduleName, module):
            # return a path_entry to use for child packages
 
    Namespace handlers are only called if the importer object has already
    agreed that it can handle the relevant path item, and they should only
    return a subpath if the module __path__ does not already contain an
    equivalent subpath.  For an example namespace handler, see
    ``pkg_resources.file_ns_handler``.
    """
    _namespace_handlers[importer_type] = namespace_handler
 
 

◆ resolve_egg_link()

resolve_egg_link ( path )

Given a path to an .egg-link, resolve distributions
present in the referenced path.

Definition at line 2218 of file __init__.py.

def resolve_egg_link(path):
    """
    Given a path to an .egg-link, resolve distributions
    present in the referenced path.
    """
    referenced_paths = non_empty_lines(path)
    resolved_paths = (
        os.path.join(os.path.dirname(path), ref) for ref in referenced_paths
    )
    dist_groups = map(find_distributions, resolved_paths)
    return next(dist_groups, ())
 
 

◆ run_script()

run_script	(	dist_spec,
		script_name
	)

Locate distribution `dist_spec` and run its `script_name` script

Definition at line 510 of file __init__.py.

def run_script(dist_spec, script_name):
    """Locate distribution `dist_spec` and run its `script_name` script"""
    ns = sys._getframe(1).f_globals
    name = ns['__name__']
    ns.clear()
    ns['__name__'] = name
    require(dist_spec)[0].run_script(script_name, ns)
 
 
# backward compatibility

References i, pip._vendor.pkg_resources.require, and pip._vendor.pkg_resources.run_script().

Referenced by pip._vendor.pkg_resources.run_script().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ safe_extra()

safe_extra ( extra )

Convert an arbitrary string to a standard 'extra' name

Any runs of non-alphanumeric characters are replaced with a single '_',
and the result is always lowercased.

Definition at line 1436 of file __init__.py.

def safe_extra(extra):
    """Convert an arbitrary string to a standard 'extra' name
 
    Any runs of non-alphanumeric characters are replaced with a single '_',
    and the result is always lowercased.
    """
    return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
 
 

◆ safe_listdir()

safe_listdir ( path )

Attempt to list contents of path, but suppress some exceptions.

Definition at line 2173 of file __init__.py.

def safe_listdir(path):
    """
    Attempt to list contents of path, but suppress some exceptions.
    """
    try:
        return os.listdir(path)
    except (PermissionError, NotADirectoryError):
        pass
    except OSError as e:
        # Ignore the directory if does not exist, not a directory or
        # permission denied
        if e.errno not in (errno.ENOTDIR, errno.EACCES, errno.ENOENT):
            raise
    return ()
 
 

◆ safe_name()

safe_name ( name )

Convert an arbitrary string to a standard distribution name

Any runs of non-alphanumeric/. characters are replaced with a single '-'.

Definition at line 1384 of file __init__.py.

def safe_name(name):
    """Convert an arbitrary string to a standard distribution name
 
    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
    """
    return re.sub('[^A-Za-z0-9.]+', '-', name)
 
 

◆ safe_version()

safe_version ( version )

Convert an arbitrary string to a standard version string

Definition at line 1392 of file __init__.py.

def safe_version(version):
    """
    Convert an arbitrary string to a standard version string
    """
    try:
        # normalize the version
        return str(packaging.version.Version(version))
    except packaging.version.InvalidVersion:
        version = version.replace(' ', '.')
        return re.sub('[^A-Za-z0-9.]+', '-', version)
 
 

◆ split_sections()

split_sections ( s )

Split a string or iterable thereof into (section, content) pairs

Each ``section`` is a stripped version of the section header ("[section]")
and each ``content`` is a list of stripped lines excluding blank lines and
comment-only lines.  If there are any such lines before the first section
header, they're returned in a first ``section`` of ``None``.

Definition at line 3256 of file __init__.py.

def split_sections(s):
    """Split a string or iterable thereof into (section, content) pairs
 
    Each ``section`` is a stripped version of the section header ("[section]")
    and each ``content`` is a list of stripped lines excluding blank lines and
    comment-only lines.  If there are any such lines before the first section
    header, they're returned in a first ``section`` of ``None``.
    """
    section = None
    content = []
    for line in yield_lines(s):
        if line.startswith("["):
            if line.endswith("]"):
                if section or content:
                    yield section, content
                section = line[1:-1].strip()
                content = []
            else:
                raise ValueError("Invalid section heading", line)
        else:
            content.append(line)
 
    # wrap up last segment
    yield section, content
 
 

◆ to_filename()

to_filename ( name )

Convert a project or version name to its filename-escaped form

Any '-' characters are currently replaced with '_'.

Definition at line 1445 of file __init__.py.

def to_filename(name):
    """Convert a project or version name to its filename-escaped form
 
    Any '-' characters are currently replaced with '_'.
    """
    return name.replace('-', '_')
 
 

Variable Documentation

◆ _distribution_finders

_distribution_finders = None

protected

Definition at line 113 of file __init__.py.

◆ _distributionImpl

dict _distributionImpl

protected

Initial value:

=  {
    '.egg': Distribution,
    '.egg-info': EggInfoDistribution,
    '.dist-info': DistInfoDistribution,
}

Definition at line 3138 of file __init__.py.

◆ _namespace_handlers

_namespace_handlers = None

protected

Definition at line 114 of file __init__.py.

◆ _namespace_packages

_namespace_packages = None

protected

Definition at line 115 of file __init__.py.

◆ _PEP440_FALLBACK

_PEP440_FALLBACK = re.compile(r"^v?(?P<safe>(?:[0-9]+!)?[0-9]+(?:\.[0-9]+)*)", re.I)

protected

Definition at line 126 of file __init__.py.

◆ _provider_factories

dict _provider_factories = {}

protected

Definition at line 377 of file __init__.py.

◆ _sget_none

None _sget_none = lambda *args

protected

Definition at line 179 of file __init__.py.

◆ _state_vars

dict _state_vars = {}

protected

Definition at line 139 of file __init__.py.

◆ add_activation_listener

add_activation_listener = None

Definition at line 101 of file __init__.py.

◆ append

append

Definition at line 3297 of file __init__.py.

◆ AvailableDistributions

AvailableDistributions = Environment

Definition at line 1176 of file __init__.py.

◆ BINARY_DIST

int BINARY_DIST = 2

Definition at line 381 of file __init__.py.

◆ category

◆ CHECKOUT_DIST

int CHECKOUT_DIST = 0

Definition at line 383 of file __init__.py.

◆ cleanup_resources

cleanup_resources = None

Definition at line 103 of file __init__.py.

◆ darwinVersionString

darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")

Definition at line 456 of file __init__.py.

◆ DEVELOP_DIST

int DEVELOP_DIST = -1

Definition at line 384 of file __init__.py.

◆ EGG_DIST

int EGG_DIST = 3

Definition at line 380 of file __init__.py.

◆ EGG_NAME

EGG_NAME

Initial value:

=  re.compile(
    ,
    re.VERBOSE | re.IGNORECASE,
).match

Definition at line 2468 of file __init__.py.

◆ empty_provider

empty_provider = EmptyProvider()

Definition at line 1761 of file __init__.py.

◆ FileExistsError

FileExistsError = OSError

Definition at line 55 of file __init__.py.

◆ get_platform

get_platform = get_build_platform

Definition at line 458 of file __init__.py.

Referenced by pip._vendor.pkg_resources.get_build_platform().

◆ importlib_machinery

importlib_machinery = None

Definition at line 77 of file __init__.py.

◆ iter_entry_points

iter_entry_points = None

Definition at line 109 of file __init__.py.

◆ macosVersionString

macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")

Definition at line 455 of file __init__.py.

◆ MODULE

MODULE = re.compile(r"\w+(\.\w+)*$").match

Definition at line 2467 of file __init__.py.

◆ parse_version

parse_version = packaging.version.Version

Definition at line 136 of file __init__.py.

◆ PEP440Warning

PEP440Warning

Definition at line 3297 of file __init__.py.

◆ PY_MAJOR

str PY_MAJOR = '{}.{}'.format(*sys.version_info)

Definition at line 379 of file __init__.py.

◆ require

require = None

Definition at line 99 of file __init__.py.

Referenced by pip._vendor.pkg_resources.get_provider(), and pip._vendor.pkg_resources.run_script().

◆ resource_dir

resource_dir = None

Definition at line 104 of file __init__.py.

◆ resource_exists

resource_exists = None

Definition at line 112 of file __init__.py.

◆ resource_filename

resource_filename = None

Definition at line 111 of file __init__.py.

◆ resource_isdir

resource_isdir = None

Definition at line 107 of file __init__.py.

◆ resource_listdir

resource_listdir = None

Definition at line 110 of file __init__.py.

◆ resource_stream

resource_stream = None

Definition at line 105 of file __init__.py.

◆ resource_string

resource_string = None

Definition at line 108 of file __init__.py.

◆ resources_stream

resources_stream = None

Definition at line 102 of file __init__.py.

◆ run_main

run_main = run_script

Definition at line 520 of file __init__.py.

◆ set_extraction_path

set_extraction_path = None

Definition at line 106 of file __init__.py.

◆ SOURCE_DIST

int SOURCE_DIST = 1

Definition at line 382 of file __init__.py.

◆ stacklevel

stacklevel

Definition at line 122 of file __init__.py.

◆ working_set

working_set = None

Definition at line 100 of file __init__.py.

◆ WRITE_SUPPORT

bool WRITE_SUPPORT = True

Definition at line 63 of file __init__.py.

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ __getstate__()

◆ __setstate__()

◆ _always_object()

◆ _bypass_ensure_directory()

◆ _call_aside()

◆ _cygwin_patch()

◆ _declare_state()

◆ _find_adapter()

◆ _forgiving_version()

◆ _handle_ns()

◆ _initialize()

◆ _initialize_master_working_set()

◆ _is_egg_path()

◆ _is_unpacked_egg()

◆ _is_zip_egg()

◆ _macos_arch()

◆ _macos_vers()

◆ _mkstemp()

◆ _normalize_cached()

◆ _parents()

◆ _rebuild_mod_path()

◆ _safe_segment()

◆ _set_parent_ns()

◆ _sget_dict()

◆ _sget_object()

◆ _sset_dict()

◆ _sset_object()

◆ _version_from_file()

◆ compatible_platforms()

◆ declare_namespace()

◆ dist_factory()

◆ distributions_from_metadata()

◆ ensure_directory()

◆ evaluate_marker()

◆ file_ns_handler()

◆ find_distributions()

◆ find_eggs_in_zip()

◆ find_nothing()

◆ find_on_path()

◆ fixup_namespace_packages()

◆ get_build_platform()

◆ get_default_cache()

◆ get_distribution()

◆ get_entry_info()

◆ get_entry_map()

◆ get_provider()

◆ get_supported_platform()

◆ invalid_marker()

◆ issue_warning()

◆ load_entry_point()

◆ non_empty_lines()

◆ normalize_path()

◆ null_ns_handler()

◆ parse_requirements()

◆ register_finder()

◆ register_loader_type()

◆ register_namespace_handler()

◆ resolve_egg_link()

◆ run_script()

◆ safe_extra()

◆ safe_listdir()

◆ safe_name()

◆ safe_version()

◆ split_sections()

◆ to_filename()

Variable Documentation

◆ _distribution_finders

◆ _distributionImpl

◆ _namespace_handlers

◆ _namespace_packages

◆ _PEP440_FALLBACK

◆ _provider_factories

◆ _sget_none

◆ _state_vars

◆ add_activation_listener

◆ getstate()

◆ setstate()