"""

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.

"""

from __future__ import absolute_import

import sys

import os

import io

import time

import re

import types

import zipfile

import zipimport

import warnings

import stat

import functools

import pkgutil

import token

import symbol

import operator

import platform

import collections

import plistlib

import email.parser

import tempfile

import textwrap

from pkgutil import get_importer

try:

import _imp

except ImportError:

# Python 3.2 compatibility

import imp as _imp

PY3 = sys.version_info > (3,)

PY2 = not PY3

if PY3:

from urllib.parse import urlparse, urlunparse

if PY2:

from urlparse import urlparse, urlunparse

if PY3:

string_types = str,

else:

string_types = str, eval('unicode')

iteritems = (lambda i: i.items()) if PY3 else lambda i: i.iteritems()

# capture these to bypass sandboxing

from os import utime

try:

from os import mkdir, rename, unlink

WRITE_SUPPORT = True

except ImportError:

# no write support, probably under GAE

WRITE_SUPPORT = False

from os import open as os_open

from os.path import isdir, split

# Avoid try/except due to potential problems with delayed import mechanisms.

if sys.version_info >= (3, 3) and sys.implementation.name == "cpython":

import importlib.machinery as importlib_machinery

else:

importlib_machinery = None

try:

import parser

except ImportError:

pass

try:

import pkg_resources._vendor.packaging.version

import pkg_resources._vendor.packaging.specifiers

packaging = pkg_resources._vendor.packaging

except ImportError:

# fallback to naturally-installed version; allows system packagers to

# omit vendored packages.

import packaging.version

import packaging.specifiers

# declare some globals that will be defined later to

# satisfy the linters.

require = None

working_set = None

class PEP440Warning(RuntimeWarning):

"""

Used when there is an issue with a version or specifier not complying with

PEP 440.

"""

class _SetuptoolsVersionMixin(object):

def __hash__(self):

return super(_SetuptoolsVersionMixin, self).__hash__()

def __lt__(self, other):

if isinstance(other, tuple):

return tuple(self) < other

else:

return super(_SetuptoolsVersionMixin, self).__lt__(other)

def __le__(self, other):

if isinstance(other, tuple):

return tuple(self) <= other

else:

return super(_SetuptoolsVersionMixin, self).__le__(other)

def __eq__(self, other):

if isinstance(other, tuple):

return tuple(self) == other

else:

return super(_SetuptoolsVersionMixin, self).__eq__(other)

def __ge__(self, other):

if isinstance(other, tuple):

return tuple(self) >= other

else:

return super(_SetuptoolsVersionMixin, self).__ge__(other)

def __gt__(self, other):

if isinstance(other, tuple):

return tuple(self) > other

else:

return super(_SetuptoolsVersionMixin, self).__gt__(other)

def __ne__(self, other):

if isinstance(other, tuple):

return tuple(self) != other

else:

return super(_SetuptoolsVersionMixin, self).__ne__(other)

def __getitem__(self, key):

return tuple(self)[key]

def __iter__(self):

component_re = re.compile(r'(\d+ | [a-z]+ | \.| -)', re.VERBOSE)

replace = {

'pre': 'c',

'preview': 'c',

'-': 'final-',

'rc': 'c',

'dev': '@',

}.get

def _parse_version_parts(s):

for part in component_re.split(s):

part = replace(part, part)

if not part or part == '.':

continue

if part[:1] in '0123456789':

# pad for numeric comparison

yield part.zfill(8)

else:

yield '*'+part

# ensure that alpha/beta/candidate are before final

yield '*final'

def old_parse_version(s):

parts = []

for part in _parse_version_parts(s.lower()):

if part.startswith('*'):

# remove '-' before a prerelease tag

if part < '*final':

while parts and parts[-1] == '*final-':

parts.pop()

# remove trailing zeros from each series of numeric parts

while parts and parts[-1] == '00000000':

parts.pop()

parts.append(part)

return tuple(parts)

# Warn for use of this function

warnings.warn(

"You have iterated over the result of "

"pkg_resources.parse_version. This is a legacy behavior which is "

"inconsistent with the new version class introduced in setuptools "

"8.0. In most cases, conversion to a tuple is unnecessary. For "

"comparison of versions, sort the Version instances directly. If "

"you have another use case requiring the tuple, please file a "

"bug with the setuptools project describing that need.",

RuntimeWarning,

stacklevel=1,

)

for part in old_parse_version(str(self)):

yield part

class SetuptoolsVersion(_SetuptoolsVersionMixin, packaging.version.Version):

pass

class SetuptoolsLegacyVersion(_SetuptoolsVersionMixin,

packaging.version.LegacyVersion):

pass

def parse_version(v):

try:

return SetuptoolsVersion(v)

except packaging.version.InvalidVersion:

return SetuptoolsLegacyVersion(v)

_state_vars = {}

def _declare_state(vartype, **kw):

globals().update(kw)

_state_vars.update(dict.fromkeys(kw, vartype))

def __getstate__():

state = {}

g = globals()

for k, v in _state_vars.items():

state[k] = g['_sget_'+v](g[k])

return state

def __setstate__(state):

g = globals()

for k, v in state.items():

g['_sset_'+_state_vars[k]](k, g[k], v)

return state

def _sget_dict(val):

return val.copy()

def _sset_dict(key, ob, state):

ob.clear()

ob.update(state)

def _sget_object(val):

return val.__getstate__()

def _sset_object(key, ob, state):

ob.__setstate__(state)

_sget_none = _sset_none = lambda *args: None

def get_supported_platform():

"""Return this platform's maximum compatible version.

distutils.util.get_platform() normally reports the minimum version

of Mac OS X that would be required to *use* extensions produced by

distutils. But what we want when checking compatibility is to know the

version of Mac OS X that we are *running*. To allow usage of packages that

explicitly require a newer version of Mac OS X, 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(_macosx_vers()[:2]), m.group(3))

except ValueError:

# not Mac OS X

pass

return plat

__all__ = [

# Basic resource access and distribution/entry point discovery

'require', 'run_script', 'get_provider', 'get_distribution',

'load_entry_point', 'get_entry_map', 'get_entry_info',

'iter_entry_points',

'resource_string', 'resource_stream', 'resource_filename',

'resource_listdir', 'resource_exists', 'resource_isdir',

# Environmental control

'declare_namespace', 'working_set', 'add_activation_listener',

'find_distributions', 'set_extraction_path', 'cleanup_resources',

'get_default_cache',

# Primary implementation classes

'Environment', 'WorkingSet', 'ResourceManager',

'Distribution', 'Requirement', 'EntryPoint',

# Exceptions

'ResolutionError', 'VersionConflict', 'DistributionNotFound',

'UnknownExtra', 'ExtractionError',

# Warnings

'PEP440Warning',

# Parsing functions and string utilities

'parse_requirements', 'parse_version', 'safe_name', 'safe_version',

'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',

'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',

# filesystem utilities

'ensure_directory', 'normalize_path',

# Distribution "precedence" constants

'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',

# "Provider" interfaces, implementations, and registration/lookup APIs

'IMetadataProvider', 'IResourceProvider', 'FileMetadata',

'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',

'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',

'register_finder', 'register_namespace_handler', 'register_loader_type',

'fixup_namespace_packages', 'get_importer',

# Deprecated/backward compatibility only

'run_main', 'AvailableDistributions',

]

class ResolutionError(Exception):

"""Abstract base for dependency resolution errors"""

def __repr__(self):

return self.__class__.__name__+repr(self.args)

class VersionConflict(ResolutionError):

"""

An already-installed version conflicts with the requested version.

Should be initialized with the installed Distribution and the requested

Requirement.

"""

_template = "{self.dist} is installed but {self.req} is required"

@property

def dist(self):

return self.args[0]

@property

def req(self):

return self.args[1]

def report(self):

return self._template.format(**locals())

def with_context(self, required_by):

"""

If required_by is non-empty, return a version of self that is a

ContextualVersionConflict.

"""

if not required_by:

return self

args = self.args + (required_by,)

return ContextualVersionConflict(*args)

class ContextualVersionConflict(VersionConflict):

"""

A VersionConflict that accepts a third parameter, the set of the

requirements that required the installed Distribution.

"""

_template = VersionConflict._template + ' by {self.required_by}'

@property

def required_by(self):

return self.args[2]

class DistributionNotFound(ResolutionError):

"""A requested distribution was not found"""

_template = ("The '{self.req}' distribution was not found "

"and is required by {self.requirers_str}")

@property

def req(self):

return self.args[0]

@property

def requirers(self):

return self.args[1]

@property

def requirers_str(self):

if not self.requirers:

return 'the application'

return ', '.join(self.requirers)

def report(self):

return self._template.format(**locals())

def __str__(self):

return self.report()

class UnknownExtra(ResolutionError):

"""Distribution doesn't have an "extra feature" of the given name"""

_provider_factories = {}

PY_MAJOR = sys.version[:3]

EGG_DIST = 3

BINARY_DIST = 2

SOURCE_DIST = 1

CHECKOUT_DIST = 0

DEVELOP_DIST = -1

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

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)

def _macosx_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]

def _macosx_arch(machine):

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

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 Mac OS X.

"""

try:

# Python 2.7 or >=3.2

from sysconfig import get_platform

except ImportError:

from distutils.util import get_platform

plat = get_platform()

if sys.platform == "darwin" and not plat.startswith('macosx-'):

try:

version = _macosx_vers()

machine = os.uname()[4].replace(" ", "_")

return "macosx-%d.%d-%s" % (int(version[0]), int(version[1]),

_macosx_arch(machine))

except ValueError:

# if someone is running a non-Mac darwin system, this will fall

# through to the default implementation

pass

return plat

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

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

# XXX backward compat

get_platform = get_build_platform

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

# Mac OS X 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 macosx 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 macosx 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

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

run_main = run_script

def get_distribution(dist):

"""Return a current distribution object for a Requirement or string"""

if isinstance(dist, string_types):

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

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)

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)

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)

class IMetadataProvider:

def has_metadata(name):

"""Does the package's distribution contain the named metadata?"""

def get_metadata(name):

"""The named metadata resource as a string"""

def get_metadata_lines(name):

"""Yield named metadata resource as list of non-blank non-comment lines

Leading and trailing whitespace is stripped from each line, and lines

with ``#`` as the first non-blank character are omitted."""

def metadata_isdir(name):

"""Is the named metadata a directory? (like ``os.path.isdir()``)"""

def metadata_listdir(name):

"""List of metadata names in the directory (like ``os.listdir()``)"""

def run_script(script_name, namespace):

"""Execute the named script in the supplied namespace dictionary"""

class IResourceProvider(IMetadataProvider):

"""An object that provides access to package resources"""

def get_resource_filename(manager, resource_name):

"""Return a true filesystem path for `resource_name`

`manager` must be an ``IResourceManager``"""

def get_resource_stream(manager, resource_name):

"""Return a readable file-like object for `resource_name`

`manager` must be an ``IResourceManager``"""

def get_resource_string(manager, resource_name):

"""Return a string containing the contents of `resource_name`

`manager` must be an ``IResourceManager``"""

def has_resource(resource_name):

"""Does the package contain the named resource?"""

def resource_isdir(resource_name):

"""Is the named resource a directory? (like ``os.path.isdir()``)"""

def resource_listdir(resource_name):

"""List of resource names in the directory (like ``os.listdir()``)"""

class WorkingSet(object):

"""A collection of active distributions on sys.path (or a similar list)"""

def __init__(self, entries=None):

"""Create working set from list of path entries (default=sys.path)"""

self.entries = []

self.entry_keys = {}

self.by_key = {}

self.callbacks = []

if entries is None:

entries = sys.path

for entry in entries:

self.add_entry(entry)

@classmethod

def _build_master(cls):

"""

Prepare the master working set.

"""

ws = cls()

try:

from __main__ import __requires__

except ImportError:

# The main program does not list any requirements

return ws

# ensure the requirements are met

try:

ws.require(__requires__)

except VersionConflict:

return cls._build_from_requirements(__requires__)

return ws

@classmethod

def _build_from_requirements(cls, req_spec):

"""

Build a working set from a requirement spec. Rewrites sys.path.

"""

# try it without defaults already on sys.path

# by starting with an empty path

ws = cls([])

reqs = parse_requirements(req_spec)

dists = ws.resolve(reqs, Environment())

for dist in dists:

ws.add(dist)

# add any missing entries from sys.path

for entry in sys.path:

if entry not in ws.entries:

ws.add_entry(entry)

# then copy back to sys.path

sys.path[:] = ws.entries

return ws

def add_entry(self, entry):

"""Add a path item to ``.entries``, finding any distributions on it

``find_distributions(entry, True)`` is used to find distributions

corresponding to the path entry, and they are added. `entry` is

always appended to ``.entries``, even if it is already present.

(This is because ``sys.path`` can contain the same value more than

once, and the ``.entries`` of the ``sys.path`` WorkingSet should always

equal ``sys.path``.)

"""

self.entry_keys.setdefault(entry, [])

self.entries.append(entry)

for dist in find_distributions(entry, True):

self.add(dist, entry, False)

def __contains__(self, dist):

"""True if `dist` is the active distribution for its project"""

return self.by_key.get(dist.key) == dist

def find(self, req):

"""Find a distribution matching requirement `req`

If there is an active distribution for the requested project, this

returns it as long as it meets the version requirement specified by

`req`. But, if there is an active distribution for the project and it

does *not* meet the `req` requirement, ``VersionConflict`` is raised.

If there is no active distribution for the requested project, ``None``

is returned.

"""

dist = self.by_key.get(req.key)

if dist is not None and dist not in req:

# XXX add more info

raise VersionConflict(dist, req)

return dist

def iter_entry_points(self, group, name=None):

"""Yield entry point objects from `group` matching `name`

If `name` is None, yields all entry points in `group` from all

distributions in the working set, otherwise only ones matching

both `group` and `name` are yielded (in distribution order).

"""

for dist in self:

entries = dist.get_entry_map(group)

if name is None:

for ep in entries.values():

yield ep

elif name in entries:

yield entries[name]

def run_script(self, requires, script_name):

"""Locate distribution for `requires` and run `script_name` script"""

ns = sys._getframe(1).f_globals

name = ns['__name__']

ns.clear()

ns['__name__'] = name

self.require(requires)[0].run_script(script_name, ns)

def __iter__(self):

"""Yield distributions for non-duplicate projects in the working set

The yield order is the order in which the items' path entries were

added to the working set.

"""

seen = {}

for item in self.entries:

if item not in self.entry_keys:

# workaround a cache issue

continue

for key in self.entry_keys[item]:

if key not in seen:

seen[key]=1

yield self.by_key[key]

def add(self, dist, entry=None, insert=True, replace=False):

"""Add `dist` to working set, associated with `entry`

If `entry` is unspecified, it defaults to the ``.location`` of `dist`.

On exit from this routine, `entry` is added to the end of the working

set's ``.entries`` (if it wasn't already present).

`dist` is only added to the working set if it's for a project that

doesn't already have a distribution in the set, unless `replace=True`.

If it's added, any callbacks registered with the ``subscribe()`` method

will be called.

"""

if insert:

dist.insert_on(self.entries, entry)

if entry is None:

entry = dist.location

keys = self.entry_keys.setdefault(entry,[])

keys2 = self.entry_keys.setdefault(dist.location,[])

if not replace and dist.key in self.by_key:

# ignore hidden distros

return

self.by_key[dist.key] = dist

if dist.key not in keys:

keys.append(dist.key)

if dist.key not in keys2:

keys2.append(dist.key)

self._added_new(dist)

def resolve(self, requirements, env=None, installer=None,

replace_conflicting=False):

"""List all distributions needed to (recursively) meet `requirements`

`requirements` must be a sequence of ``Requirement`` objects. `env`,

if supplied, should be an ``Environment`` instance. If

not supplied, it defaults to all distributions available within any

entry or distribution in the working set. `installer`, if supplied,

will be invoked with each requirement that cannot be met by an

already-installed distribution; it should return a ``Distribution`` or

``None``.

Unless `replace_conflicting=True`, raises a VersionConflict exception if

any requirements are found on the path that have the correct name but

the wrong version. Otherwise, if an `installer` is supplied it will be

invoked to obtain the correct version of the requirement and activate

it.

"""

# set up the stack

requirements = list(requirements)[::-1]

# set of processed requirements

processed = {}

# key -> dist

best = {}

to_activate = []

# Mapping of requirement to set of distributions that required it;

# useful for reporting info about conflicts.

required_by = collections.defaultdict(set)

while requirements:

# process dependencies breadth-first

req = requirements.pop(0)

if req in processed:

# Ignore cyclic or redundant dependencies

continue

dist = best.get(req.key)

if dist is None:

# Find the best distribution and add it to the map

dist = self.by_key.get(req.key)

if dist is None or (dist not in req and replace_conflicting):

ws = self

if env is None:

if dist is None:

env = Environment(self.entries)

else:

# Use an empty environment and workingset to avoid

# any further conflicts with the conflicting

# distribution

env = Environment([])

ws = WorkingSet([])

dist = best[req.key] = env.best_match(req, ws, installer)

if dist is None:

requirers = required_by.get(req, None)

raise DistributionNotFound(req, requirers)

to_activate.append(dist)

if dist not in req:

# Oops, the "best" so far conflicts with a dependency

dependent_req = required_by[req]

raise VersionConflict(dist, req).with_context(dependent_req)

# push the new requirements onto the stack

new_requirements = dist.requires(req.extras)[::-1]

requirements.extend(new_requirements)

# Register the new requirements needed by req

for new_requirement in new_requirements:

required_by[new_requirement].add(req.project_name)

processed[req] = True

# return list of distros to activate

return to_activate

def find_plugins(self, plugin_env, full_env=None, installer=None,

fallback=True):

"""Find all activatable distributions in `plugin_env`

Example usage::

distributions, errors = working_set.find_plugins(

Environment(plugin_dirlist)

)

# add plugins+libs to sys.path

map(working_set.add, distributions)

# display errors

print('Could not load', errors)

The `plugin_env` should be an ``Environment`` instance that contains

only distributions that are in the project's "plugin directory" or

directories. The `full_env`, if supplied, should be an ``Environment``

contains all currently-available distributions. If `full_env` is not

supplied, one is created automatically from the ``WorkingSet`` this

method is called on, which will typically mean that every directory on

``sys.path`` will be scanned for distributions.

`installer` is a standard installer callback as used by the

``resolve()`` method. The `fallback` flag indicates whether we should

attempt to resolve older versions of a plugin if the newest version

cannot be resolved.

This method returns a 2-tuple: (`distributions`, `error_info`), where

`distributions` is a list of the distributions found in `plugin_env`

that were loadable, along with any other distributions that are needed

to resolve their dependencies. `error_info` is a dictionary mapping

unloadable plugin distributions to an exception instance describing the

error that occurred. Usually this will be a ``DistributionNotFound`` or

``VersionConflict`` instance.

"""

plugin_projects = list(plugin_env)

# scan project names in alphabetic order

plugin_projects.sort()

error_info = {}

distributions = {}

if full_env is None:

env = Environment(self.entries)

env += plugin_env

else:

env = full_env + plugin_env

shadow_set = self.__class__([])

# put all our entries in shadow_set

list(map(shadow_set.add, self))

for project_name in plugin_projects:

for dist in plugin_env[project_name]:

req = [dist.as_requirement()]

try:

resolvees = shadow_set.resolve(req, env, installer)

except ResolutionError as v:

# save error info

error_info[dist] = v

if fallback:

# try the next older version of project

continue

else:

# give up on this project, keep going

break

else:

list(map(shadow_set.add, resolvees))

distributions.update(dict.fromkeys(resolvees))

# success, no need to try any more versions of this project

break

distributions = list(distributions)

distributions.sort()

return distributions, error_info

def require(self, *requirements):

"""Ensure that distributions matching `requirements` are activated

`requirements` must be a string or a (possibly-nested) sequence

thereof, specifying the distributions and versions required. The

return value is a sequence of the distributions that needed to be

activated to fulfill the requirements; all relevant distributions are

included, even if they were already activated in this working set.

"""

needed = self.resolve(parse_requirements(requirements))

for dist in needed:

self.add(dist)

return needed

def subscribe(self, callback):

"""Invoke `callback` for all distributions (including existing ones)"""

if callback in self.callbacks:

return

self.callbacks.append(callback)

for dist in self:

callback(dist)

def _added_new(self, dist):

for callback in self.callbacks:

callback(dist)

def __getstate__(self):

return (

self.entries[:], self.entry_keys.copy(), self.by_key.copy(),

self.callbacks[:]

)

def __setstate__(self, e_k_b_c):

entries, keys, by_key, callbacks = e_k_b_c

self.entries = entries[:]

self.entry_keys = keys.copy()

self.by_key = by_key.copy()

self.callbacks = callbacks[:]

class Environment(object):

"""Searchable snapshot of distributions on a search path"""

def __init__(self, search_path=None, platform=get_supported_platform(),

python=PY_MAJOR):

"""Snapshot distributions available on a search path

Any distributions found on `search_path` are added to the environment.

`search_path` should be a sequence of ``sys.path`` items. If not

supplied, ``sys.path`` is used.

`platform` is an optional string specifying the name of the platform

that platform-specific distributions must be compatible with. If

unspecified, it defaults to the current platform. `python` is an

optional string naming the desired version of Python (e.g. ``'3.3'``);

it defaults to the current version.