Maximum CD 2012 January/maximum-cd-2012-01.iso/DiscContents/digsby_setup.exe/lib/pkg_resources.pyo

Python Compiled Bytecode | 2011-10-05 | 58.9 KB | 2,077 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

import sys
import os
import zipimport
import time
import re
import imp
import pkgutil

try:
    frozenset
except NameError:
    from sets import ImmutableSet as frozenset

from os import utime, rename, unlink, mkdir
from os import open as os_open
from os.path import isdir, split

def _bypass_ensure_directory(name, mode = 511):
    (dirname, filename) = split(name)
    if dirname and filename and not isdir(dirname):
        _bypass_ensure_directory(dirname)
        mkdir(dirname, mode)


_state_vars = { }

def _declare_state(vartype, **kw):
    g = globals()
    for name, val in kw.iteritems():
        g[name] = val
        _state_vars[name] = vartype



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

    return state


def __setstate__(state):
    g = globals()
    for k, v in state.iteritems():
        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 : pass)

def get_supported_platform():
    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:
            pass
        except:
            None<EXCEPTION MATCH>ValueError


    None<EXCEPTION MATCH>ValueError
    return plat

__all__ = [
    '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',
    'declare_namespace',
    'working_set',
    'add_activation_listener',
    'find_distributions',
    'set_extraction_path',
    'cleanup_resources',
    'get_default_cache',
    'Environment',
    'WorkingSet',
    'ResourceManager',
    'Distribution',
    'Requirement',
    'EntryPoint',
    'ResolutionError',
    'VersionConflict',
    'DistributionNotFound',
    'UnknownExtra',
    'ExtractionError',
    'parse_requirements',
    'parse_version',
    'safe_name',
    'safe_version',
    'get_platform',
    'compatible_platforms',
    'yield_lines',
    'split_sections',
    'safe_extra',
    'to_filename',
    'ensure_directory',
    'normalize_path',
    'EGG_DIST',
    'BINARY_DIST',
    'SOURCE_DIST',
    'CHECKOUT_DIST',
    'DEVELOP_DIST',
    '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',
    'run_main',
    'AvailableDistributions']

class ResolutionError(Exception):

    def __repr__(self):
        return self.__class__.__name__ + repr(self.args)



class VersionConflict(ResolutionError):
    pass


class DistributionNotFound(ResolutionError):
    pass


class UnknownExtra(ResolutionError):
    pass

_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):
    _provider_factories[loader_type] = provider_factory


def get_provider(moduleOrReq):
    if isinstance(moduleOrReq, Requirement):
        if not working_set.find(moduleOrReq):
            pass
        return require(str(moduleOrReq))[0]

    try:
        module = sys.modules[moduleOrReq]
    except KeyError:
        isinstance(moduleOrReq, Requirement)
        isinstance(moduleOrReq, Requirement)
        __import__(moduleOrReq)
        module = sys.modules[moduleOrReq]
    except:
        isinstance(moduleOrReq, Requirement)

    loader = getattr(module, '__loader__', None)
    return _find_adapter(_provider_factories, loader)(module)


def _macosx_vers(_cache = []):
    if not _cache:
        mac_ver = mac_ver
        import platform
        _cache.append(mac_ver()[0].split('.'))

    return _cache[0]


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


def get_build_platform():
    get_platform = get_platform
    import distutils.util
    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:
            pass
        except:
            None<EXCEPTION MATCH>ValueError


    None<EXCEPTION MATCH>ValueError
    return plat

macosVersionString = re.compile('macosx-(\\d+)\\.(\\d+)-(.*)')
darwinVersionString = re.compile('darwin-(\\d+)\\.(\\d+)\\.(\\d+)-(.*)')
get_platform = get_build_platform

def compatible_platforms(provided, required):
    if provided is None and required is None or provided == required:
        return True
    reqMac = macosVersionString.match(required)
    if reqMac:
        provMac = macosVersionString.match(provided)
        if not provMac:
            provDarwin = darwinVersionString.match(provided)
            return False
        if provMac.group(1) != reqMac.group(1) or provMac.group(3) != reqMac.group(3):
            return False
        if int(provMac.group(2)) > int(reqMac.group(2)):
            return False
        return True
    return False


def run_script(dist_spec, script_name):
    ns = sys._getframe(1).f_globals
    name = ns['__name__']
    ns.clear()
    ns['__name__'] = name
    require(dist_spec)[0].run_script(script_name, ns)

run_main = run_script

def get_distribution(dist):
    if isinstance(dist, basestring):
        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)
    isinstance(dist, Distribution)
    return dist


def load_entry_point(dist, group, name):
    return get_distribution(dist).load_entry_point(group, name)


def get_entry_map(dist, group = None):
    return get_distribution(dist).get_entry_map(group)


def get_entry_info(dist, group, name):
    return get_distribution(dist).get_entry_info(group, name)


try:
    from pkgutil import get_importer
except ImportError:
    import _pkgutil as pkgutil
    get_importer = pkgutil.get_importer

import pkgutil

class IMetadataProvider:

    def has_metadata(name):
        pass


    def get_metadata(name):
        pass


    def get_metadata_lines(name):
        pass


    def metadata_isdir(name):
        pass


    def metadata_listdir(name):
        pass


    def run_script(script_name, namespace):
        pass



class IResourceProvider(IMetadataProvider):

    def get_resource_filename(manager, resource_name):
        pass


    def get_resource_stream(manager, resource_name):
        pass


    def get_resource_string(manager, resource_name):
        pass


    def has_resource(resource_name):
        pass


    def resource_isdir(resource_name):
        pass


    def resource_listdir(resource_name):
        pass



class WorkingSet(object):

    def __init__(self, entries = None):
        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)



    def add_entry(self, entry):
        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):
        return self.by_key.get(dist.key) == dist


    def find(self, req):
        dist = self.by_key.get(req.key)
        if dist is not None and dist not in req:
            raise VersionConflict(dist, req)
        dist not in req
        return dist


    def iter_entry_points(self, group, name = None):
        for dist in self:
            entries = dist.get_entry_map(group)
            if name is None:
                for ep in entries.values():
                    yield ep

            if name in entries:
                yield entries[name]
                continue



    def run_script(self, requires, script_name):
        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):
        seen = { }
        for item in self.entries:
            for key in self.entry_keys[item]:
                if key not in seen:
                    seen[key] = 1
                    yield self.by_key[key]
                    continue




    def add(self, dist, entry = None, insert = True):
        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 dist.key in self.by_key:
            return None
        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):
        requirements = list(requirements)[::-1]
        processed = { }
        best = { }
        to_activate = []
        while requirements:
            req = requirements.pop(0)
            if req in processed:
                continue

            dist = best.get(req.key)
            if dist is None:
                dist = self.by_key.get(req.key)
                if dist is None:
                    if env is None:
                        env = Environment(self.entries)

                    dist = best[req.key] = env.best_match(req, self, installer)
                    if dist is None:
                        raise DistributionNotFound(req)
                    dist is None

                to_activate.append(dist)

            if dist not in req:
                raise VersionConflict(dist, req)
            dist not in req
            requirements.extend(dist.requires(req.extras)[::-1])
            processed[req] = True
        return to_activate


    def find_plugins(self, plugin_env, full_env = None, installer = None, fallback = True):
        plugin_projects = list(plugin_env)
        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__([])
        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:
                    v = None
                    error_info[dist] = v
                    if fallback:
                        continue
                    else:
                        break
                    fallback

                map(shadow_set.add, resolvees)
                distributions.update(dict.fromkeys(resolvees))


        distributions = list(distributions)
        distributions.sort()
        return (distributions, error_info)


    def require(self, *requirements):
        needed = self.resolve(parse_requirements(requirements))
        for dist in needed:
            self.add(dist)

        return needed


    def subscribe(self, callback):
        if callback in self.callbacks:
            return None
        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, .1):
        (entries, keys, by_key, callbacks) = .1
        self.entries = entries[:]
        self.entry_keys = keys.copy()
        self.by_key = by_key.copy()
        self.callbacks = callbacks[:]



class Environment(object):

    def __init__(self, search_path = None, platform = get_supported_platform(), python = PY_MAJOR):
        self._distmap = { }
        self._cache = { }
        self.platform = platform
        self.python = python
        self.scan(search_path)


    def can_add(self, dist):
        if self.python is None and dist.py_version is None or dist.py_version == self.python:
            pass
        return compatible_platforms(dist.platform, self.platform)


    def remove(self, dist):
        self._distmap[dist.key].remove(dist)


    def scan(self, search_path = None):
        if search_path is None:
            search_path = sys.path

        for item in search_path:
            for dist in find_distributions(item):
                self.add(dist)




    def __getitem__(self, project_name):

        try:
            return self._cache[project_name]
        except KeyError:
            project_name = project_name.lower()
            if project_name not in self._distmap:
                return []
        except:
            project_name not in self._distmap

        return self._cache[project_name]


    def add(self, dist):
        if self.can_add(dist) and dist.has_version():
            dists = self._distmap.setdefault(dist.key, [])
            if dist not in dists:
                dists.append(dist)
                if dist.key in self._cache:
                    _sort_dists(self._cache[dist.key])





    def best_match(self, req, working_set, installer = None):
        dist = working_set.find(req)
        if dist is not None:
            return dist
        for dist in self[req.key]:
            if dist in req:
                return dist

        return self.obtain(req, installer)


    def obtain(self, requirement, installer = None):
        if installer is not None:
            return installer(requirement)


    def __iter__(self):
        for key in self._distmap.keys():
            if self[key]:
                yield key
                continue



    def __iadd__(self, other):
        if isinstance(other, Distribution):
            self.add(other)
        elif isinstance(other, Environment):
            for project in other:
                for dist in other[project]:
                    self.add(dist)


        else:
            raise TypeError("Can't add %r to environment" % (other,))
        return isinstance(other, Distribution)


    def __add__(self, other):
        new = self.__class__([], platform = None, python = None)
        for env in (self, other):
            new += env

        return new


AvailableDistributions = Environment

class ExtractionError(RuntimeError):
    pass


class ResourceManager:
    extraction_path = None

    def __init__(self):
        self.cached_files = { }


    def resource_exists(self, package_or_requirement, resource_name):
        return get_provider(package_or_requirement).has_resource(resource_name)


    def resource_isdir(self, package_or_requirement, resource_name):
        return get_provider(package_or_requirement).resource_isdir(resource_name)


    def resource_filename(self, package_or_requirement, resource_name):
        return get_provider(package_or_requirement).get_resource_filename(self, resource_name)


    def resource_stream(self, package_or_requirement, resource_name):
        return get_provider(package_or_requirement).get_resource_stream(self, resource_name)


    def resource_string(self, package_or_requirement, resource_name):
        return get_provider(package_or_requirement).get_resource_string(self, resource_name)


    def resource_listdir(self, package_or_requirement, resource_name):
        return get_provider(package_or_requirement).resource_listdir(resource_name)


    def extraction_error(self):
        old_exc = sys.exc_info()[1]
        if not self.extraction_path:
            pass
        cache_path = get_default_cache()
        err = ExtractionError("Can't extract file(s) to egg cache\n\nThe following error occurred while trying to extract file(s) to the Python egg\ncache:\n\n  %s\n\nThe Python egg cache directory is currently set to:\n\n  %s\n\nPerhaps your account does not have write access to this directory?  You can\nchange the cache directory by setting the PYTHON_EGG_CACHE environment\nvariable to point to an accessible directory.\n" % (old_exc, cache_path))
        err.manager = self
        err.cache_path = cache_path
        err.original_error = old_exc
        raise err


    def get_cache_path(self, archive_name, names = ()):
        if not self.extraction_path:
            pass
        extract_path = get_default_cache()
        target_path = os.path.join(extract_path, archive_name + '-tmp', *names)

        try:
            _bypass_ensure_directory(target_path)
        except:
            self.extraction_error()

        self.cached_files[target_path] = 1
        return target_path


    def postprocess(self, tempname, filename):
        if os.name == 'posix':
            mode = (os.stat(tempname).st_mode | 365) & 4095
            os.chmod(tempname, mode)



    def set_extraction_path(self, path):
        if self.cached_files:
            raise ValueError("Can't change extraction path, files already extracted")
        self.cached_files
        self.extraction_path = path


    def cleanup_resources(self, force = False):
        pass



def get_default_cache():

    try:
        return os.environ['PYTHON_EGG_CACHE']
    except KeyError:
        pass

    if os.name != 'nt':
        return os.path.expanduser('~/.python-eggs')
    app_data = 'Application Data'
    app_homes = [
        (('APPDATA',), None),
        (('USERPROFILE',), app_data),
        (('HOMEDRIVE', 'HOMEPATH'), app_data),
        (('HOMEPATH',), app_data),
        (('HOME',), None),
        (('WINDIR',), app_data)]
    for keys, subdir in app_homes:
        dirname = ''
        for key in keys:
            if key in os.environ:
                dirname = os.path.join(dirname, os.environ[key])
                continue
            os.name != 'nt'
        elif subdir:
            dirname = os.path.join(dirname, subdir)

        return os.path.join(dirname, 'Python-Eggs')
    else:
        raise RuntimeError('Please set the PYTHON_EGG_CACHE enviroment variable')


def safe_name(name):
    return re.sub('[^A-Za-z0-9.]+', '-', name)


def safe_version(version):
    version = version.replace(' ', '.')
    return re.sub('[^A-Za-z0-9.]+', '-', version)


def safe_extra(extra):
    return re.sub('[^A-Za-z0-9.]+', '_', extra).lower()


def to_filename(name):
    return name.replace('-', '_')


class NullProvider:
    egg_name = None
    egg_info = None
    loader = None

    def __init__(self, module):
        self.loader = getattr(module, '__loader__', None)
        self.module_path = os.path.dirname(getattr(module, '__file__', ''))


    def get_resource_filename(self, manager, resource_name):
        return self._fn(self.module_path, resource_name)


    def get_resource_stream(self, manager, resource_name):
        return StringIO(self.get_resource_string(manager, resource_name))


    def get_resource_string(self, manager, resource_name):
        return self._get(self._fn(self.module_path, resource_name))


    def has_resource(self, resource_name):
        return self._has(self._fn(self.module_path, resource_name))


    def has_metadata(self, name):
        if self.egg_info:
            pass
        return self._has(self._fn(self.egg_info, name))


    def get_metadata(self, name):
        if not self.egg_info:
            return ''
        return self._get(self._fn(self.egg_info, name))


    def get_metadata_lines(self, name):
        return yield_lines(self.get_metadata(name))


    def resource_isdir(self, resource_name):
        return self._isdir(self._fn(self.module_path, resource_name))


    def metadata_isdir(self, name):
        if self.egg_info:
            pass
        return self._isdir(self._fn(self.egg_info, name))


    def resource_listdir(self, resource_name):
        return self._listdir(self._fn(self.module_path, resource_name))


    def metadata_listdir(self, name):
        if self.egg_info:
            return self._listdir(self._fn(self.egg_info, name))
        return []


    def run_script(self, script_name, namespace):
        script = 'scripts/' + script_name
        if not self.has_metadata(script):
            raise ResolutionError('No script named %r' % script_name)
        self.has_metadata(script)
        script_text = self.get_metadata(script).replace('\r\n', '\n')
        script_text = script_text.replace('\r', '\n')
        script_filename = self._fn(self.egg_info, script)
        namespace['__file__'] = script_filename
        if os.path.exists(script_filename):
            execfile(script_filename, namespace, namespace)
        else:
            cache = cache
            import linecache
            cache[script_filename] = (len(script_text), 0, script_text.split('\n'), script_filename)
            script_code = compile(script_text, script_filename, 'exec')
            exec script_code in namespace, namespace


    def _has(self, path):
        raise NotImplementedError("Can't perform this operation for unregistered loader type")


    def _isdir(self, path):
        raise NotImplementedError("Can't perform this operation for unregistered loader type")


    def _listdir(self, path):
        raise NotImplementedError("Can't perform this operation for unregistered loader type")


    def _fn(self, base, resource_name):
        if resource_name:
            return os.path.join(base, *resource_name.split('/'))
        return base


    def _get(self, path):
        if hasattr(self.loader, 'get_data'):
            return self.loader.get_data(path)
        raise NotImplementedError("Can't perform this operation for loaders without 'get_data()'")


register_loader_type(object, NullProvider)

class EggProvider(NullProvider):

    def __init__(self, module):
        NullProvider.__init__(self, module)
        self._setup_prefix()


    def _setup_prefix(self):
        path = self.module_path
        old = None
        while path != old:
            if path.lower().endswith('.egg'):
                self.egg_name = os.path.basename(path)
                self.egg_info = os.path.join(path, 'EGG-INFO')
                self.egg_root = path
                break

            old = path
            (path, base) = os.path.split(path)



class DefaultProvider(EggProvider):

    def _has(self, path):
        return os.path.exists(path)


    def _isdir(self, path):
        return os.path.isdir(path)


    def _listdir(self, path):
        return os.listdir(path)


    def get_resource_stream(self, manager, resource_name):
        return open(self._fn(self.module_path, resource_name), 'rb')


    def _get(self, path):
        stream = open(path, 'rb')

        try:
            return stream.read()
        finally:
            stream.close()



register_loader_type(type(None), DefaultProvider)

class EmptyProvider(NullProvider):
    _isdir = _has = (lambda self, path: False)

    _get = lambda self, path: ''

    _listdir = lambda self, path: []
    module_path = None

    def __init__(self):
        pass


empty_provider = EmptyProvider()

class ZipProvider(EggProvider):
    eagers = None

    def __init__(self, module):
        EggProvider.__init__(self, module)
        self.zipinfo = zipimport._zip_directory_cache[self.loader.archive]
        self.zip_pre = self.loader.archive + os.sep


    def _zipinfo_name(self, fspath):
        if fspath.startswith(self.zip_pre):
            return fspath[len(self.zip_pre):]
        raise AssertionError('%s is not a subpath of %s' % (fspath, self.zip_pre))


    def _parts(self, zip_path):
        fspath = self.zip_pre + zip_path
        if fspath.startswith(self.egg_root + os.sep):
            return fspath[len(self.egg_root) + 1:].split(os.sep)
        raise AssertionError('%s is not a subpath of %s' % (fspath, self.egg_root))


    def get_resource_filename(self, manager, resource_name):
        if not self.egg_name:
            raise NotImplementedError('resource_filename() only supported for .egg, not .zip')
        self.egg_name
        zip_path = self._resource_to_zip(resource_name)
        eagers = self._get_eager_resources()
        if '/'.join(self._parts(zip_path)) in eagers:
            for name in eagers:
                self._extract_resource(manager, self._eager_to_zip(name))


        return self._extract_resource(manager, zip_path)


    def _extract_resource(self, manager, zip_path):
        if zip_path in self._index():
            for name in self._index()[zip_path]:
                last = self._extract_resource(manager, os.path.join(zip_path, name))

            return os.path.dirname(last)
        zip_stat = self.zipinfo[zip_path]
        t = zip_stat[5]
        d = zip_stat[6]
        size = zip_stat[3]
        date_time = ((d >> 9) + 1980, d >> 5 & 15, d & 31, (t & 65535) >> 11, t >> 5 & 63, (t & 31) * 2, 0, 0, -1)
        timestamp = time.mktime(date_time)

        try:
            real_path = manager.get_cache_path(self.egg_name, self._parts(zip_path))
            (outf, tmpnam) = _mkstemp('.$extract', dir = os.path.dirname(real_path))
            os.write(outf, self.loader.get_data(zip_path))
            os.close(outf)
            utime(tmpnam, (timestamp, timestamp))
            manager.postprocess(tmpnam, real_path)

            try:
                rename(tmpnam, real_path)
            except os.error:
                None if os.path.isfile(real_path) else zip_path in self._index()
                None if os.path.isfile(real_path) else zip_path in self._index()
                raise
            except:
                None if os.path.isfile(real_path) else stat.st_mtime == timestamp

        except os.error:
            zip_path in self._index()
            zip_path in self._index()
            manager.extraction_error()
        except:
            zip_path in self._index()

        return real_path


    def _get_eager_resources(self):
        if self.eagers is None:
            eagers = []
            for name in ('native_libs.txt', 'eager_resources.txt'):
                if self.has_metadata(name):
                    eagers.extend(self.get_metadata_lines(name))
                    continue

            self.eagers = eagers

        return self.eagers


    def _index(self):

        try:
            return self._dirindex
        except AttributeError:
            ind = { }
            for path in self.zipinfo:
                parts = path.split(os.sep)
                while parts:
                    parent = os.sep.join(parts[:-1])
                    if parent in ind:
                        ind[parent].append(parts[-1])
                        break
                        continue
                    ind[parent] = [
                        parts.pop()]

            self._dirindex = ind
            return ind



    def _has(self, fspath):
        zip_path = self._zipinfo_name(fspath)
        if not zip_path in self.zipinfo:
            pass
        return zip_path in self._index()


    def _isdir(self, fspath):
        return self._zipinfo_name(fspath) in self._index()


    def _listdir(self, fspath):
        return list(self._index().get(self._zipinfo_name(fspath), ()))


    def _eager_to_zip(self, resource_name):
        return self._zipinfo_name(self._fn(self.egg_root, resource_name))


    def _resource_to_zip(self, resource_name):
        return self._zipinfo_name(self._fn(self.module_path, resource_name))


register_loader_type(zipimport.zipimporter, ZipProvider)

class FileMetadata(EmptyProvider):

    def __init__(self, path):
        self.path = path


    def has_metadata(self, name):
        return name == 'PKG-INFO'


    def get_metadata(self, name):
        if name == 'PKG-INFO':
            return open(self.path, 'rU').read()
        raise KeyError('No metadata except PKG-INFO is available')


    def get_metadata_lines(self, name):
        return yield_lines(self.get_metadata(name))



class PathMetadata(DefaultProvider):

    def __init__(self, path, egg_info):
        self.module_path = path
        self.egg_info = egg_info



class EggMetadata(ZipProvider):

    def __init__(self, importer):
        self.zipinfo = zipimport._zip_directory_cache[importer.archive]
        self.zip_pre = importer.archive + os.sep
        self.loader = importer
        if importer.prefix:
            self.module_path = os.path.join(importer.archive, importer.prefix)
        else:
            self.module_path = importer.archive
        self._setup_prefix()


_declare_state('dict', _distribution_finders = { })

def register_finder(importer_type, distribution_finder):
    _distribution_finders[importer_type] = distribution_finder


def find_distributions(path_item, only = False):
    importer = get_importer(path_item)
    finder = _find_adapter(_distribution_finders, importer)
    return finder(importer, path_item, only)


def find_in_zip(importer, path_item, only = False):
    metadata = EggMetadata(importer)
    if metadata.has_metadata('PKG-INFO'):
        yield Distribution.from_filename(path_item, metadata = metadata)

    if only:
        return None
    for subitem in metadata.resource_listdir('/'):
        if subitem.endswith('.egg'):
            subpath = os.path.join(path_item, subitem)
            for dist in find_in_zip(zipimport.zipimporter(subpath), subpath):
                yield dist
                only



register_finder(zipimport.zipimporter, find_in_zip)

def StringIO(*args, **kw):
    global StringIO, StringIO

    try:
        StringIO = StringIO
        import cStringIO
    except ImportError:
        StringIO = StringIO
        import StringIO

    return StringIO(*args, **kw)


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

register_finder(object, find_nothing)

def find_on_path(importer, path_item, only = False):
    path_item = _normalize_cached(path_item)
    if os.path.isdir(path_item) and os.access(path_item, os.R_OK):
        if path_item.lower().endswith('.egg'):
            yield Distribution.from_filename(path_item, metadata = PathMetadata(path_item, os.path.join(path_item, 'EGG-INFO')))
        else:
            for entry in os.listdir(path_item):
                lower = entry.lower()
                if lower.endswith('.egg-info'):
                    fullpath = os.path.join(path_item, entry)
                    if os.path.isdir(fullpath):
                        metadata = PathMetadata(path_item, fullpath)
                    else:
                        metadata = FileMetadata(fullpath)
                    yield Distribution.from_location(path_item, entry, metadata, precedence = DEVELOP_DIST)
                    continue
                if not only and lower.endswith('.egg'):
                    for dist in find_distributions(os.path.join(path_item, entry)):
                        yield dist

                if not only and lower.endswith('.egg-link'):
                    for line in file(os.path.join(path_item, entry)):
                        if not line.strip():
                            continue

                        for item in find_distributions(os.path.join(path_item, line.rstrip())):
                            yield item





register_finder(pkgutil.ImpImporter, find_on_path)
_declare_state('dict', _namespace_handlers = { })
_declare_state('dict', _namespace_packages = { })

def register_namespace_handler(importer_type, namespace_handler):
    _namespace_handlers[importer_type] = namespace_handler


def _handle_ns(packageName, path_item):
    importer = get_importer(path_item)
    if importer is None:
        return None
    loader = importer.find_module(packageName)
    if loader is None:
        return None
    module = sys.modules.get(packageName)
    if module is None:
        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)
        loader.load_module(packageName)
        module.__path__ = path

    return subpath


def declare_namespace(packageName):
    imp.acquire_lock()

    try:
        if packageName in _namespace_packages:
            return None
        path = sys.path
        parent = None
        if '.' in packageName:
            parent = '.'.join(packageName.split('.')[:-1])
            declare_namespace(parent)
            __import__(parent)

            try:
                path = sys.modules[parent].__path__
            except AttributeError:
                packageName in _namespace_packages
                packageName in _namespace_packages
                raise TypeError('Not a package:', parent)
            except:
                packageName in _namespace_packages<EXCEPTION MATCH>AttributeError


        packageName in _namespace_packages
        _namespace_packages.setdefault(parent, []).append(packageName)
        _namespace_packages.setdefault(packageName, [])
        for path_item in path:
            _handle_ns(packageName, path_item)
    finally:
        imp.release_lock()



def fixup_namespace_packages(path_item, parent = None):
    imp.acquire_lock()

    try:
        for package in _namespace_packages.get(parent, ()):
            subpath = _handle_ns(package, path_item)
            if subpath:
                fixup_namespace_packages(subpath, package)
                continue
    finally:
        imp.release_lock()



def file_ns_handler(importer, path_item, packageName, module):
    subpath = os.path.join(path_item, packageName.split('.')[-1])
    normalized = _normalize_cached(subpath)
    for item in module.__path__:
        if _normalize_cached(item) == normalized:
            break
            continue
    else:
        return subpath

register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
register_namespace_handler(zipimport.zipimporter, file_ns_handler)

def null_ns_handler(importer, path_item, packageName, module):
    pass

register_namespace_handler(object, null_ns_handler)

def normalize_path(filename):
    return os.path.normcase(os.path.realpath(filename))


def _normalize_cached(filename, _cache = { }):

    try:
        return _cache[filename]
    except KeyError:
        _cache[filename] = result = normalize_path(filename)
        return result



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



def yield_lines(strs):
    if isinstance(strs, basestring):
        for s in strs.splitlines():
            s = s.strip()
            if s and not s.startswith('#'):
                yield s
                continue

    else:
        for ss in strs:
            for s in yield_lines(ss):
                yield s



LINE_END = re.compile('\\s*(#.*)?$').match
CONTINUE = re.compile('\\s*\\\\\\s*(#.*)?$').match
DISTRO = re.compile('\\s*((\\w|[-.])+)').match
VERSION = re.compile('\\s*(<=?|>=?|==|!=)\\s*((\\w|[-.])+)').match
COMMA = re.compile('\\s*,').match
OBRACKET = re.compile('\\s*\\[').match
CBRACKET = re.compile('\\s*\\]').match
MODULE = re.compile('\\w+(\\.\\w+)*$').match
EGG_NAME = re.compile('(?P<name>[^-]+)( -(?P<ver>[^-]+) (-py(?P<pyver>[^-]+) (-(?P<plat>.+))? )? )?', re.VERBOSE | re.IGNORECASE).match
component_re = re.compile('(\\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':
            yield part.zfill(8)
            continue
        yield '*' + part

    yield '*final'


def parse_version(s):
    parts = []
    for part in _parse_version_parts(s.lower()):
        if part.startswith('*'):
            if part < '*final':
                while parts and parts[-1] == '*final-':
                    parts.pop()

            while parts and parts[-1] == '00000000':
                parts.pop()

        parts.append(part)

    return tuple(parts)


class EntryPoint(object):

    def __init__(self, name, module_name, attrs = (), extras = (), dist = None):
        if not MODULE(module_name):
            raise ValueError('Invalid module name', module_name)
        MODULE(module_name)
        self.name = name
        self.module_name = module_name
        self.attrs = tuple(attrs)
        self.extras = Requirement.parse('x[%s]' % ','.join(extras)).extras
        self.dist = dist


    def __str__(self):
        s = '%s = %s' % (self.name, self.module_name)
        if self.attrs:
            s += ':' + '.'.join(self.attrs)

        if self.extras:
            s += ' [%s]' % ','.join(self.extras)

        return s


    def __repr__(self):
        return 'EntryPoint.parse(%r)' % str(self)


    def load(self, require = True, env = None, installer = None):
        if require:
            self.require(env, installer)

        entry = __import__(self.module_name, globals(), globals(), [
            '__name__'])
        for attr in self.attrs:

            try:
                entry = getattr(entry, attr)
            continue
            except AttributeError:
                raise ImportError('%r has no %r attribute' % (entry, attr))
                continue



        return entry


    def require(self, env = None, installer = None):
        if self.extras and not (self.dist):
            raise UnknownExtra("Can't require() without a distribution", self)
        not (self.dist)
        map(working_set.add, working_set.resolve(self.dist.requires(self.extras), env, installer))


    def parse(cls, src, dist = None):

        try:
            attrs = extras = ()
            (name, value) = src.split('=', 1)
            if '[' in value:
                (value, extras) = value.split('[', 1)
                req = Requirement.parse('x[' + extras)
                if req.specs:
                    raise ValueError
                req.specs
                extras = req.extras

            if ':' in value:
                (value, attrs) = value.split(':', 1)
                if not MODULE(attrs.rstrip()):
                    raise ValueError
                MODULE(attrs.rstrip())
                attrs = attrs.rstrip().split('.')
        except ValueError:
            raise ValueError("EntryPoint must be in 'name=module:attrs [extras]' format", src)

        return cls(name.strip(), value.strip(), attrs, extras, dist)

    parse = classmethod(parse)

    def parse_group(cls, group, lines, dist = None):
        if not MODULE(group):
            raise ValueError('Invalid group name', group)
        MODULE(group)
        this = { }
        for line in yield_lines(lines):
            ep = cls.parse(line, dist)
            if ep.name in this:
                raise ValueError('Duplicate entry point', group, ep.name)
            ep.name in this
            this[ep.name] = ep

        return this

    parse_group = classmethod(parse_group)

    def parse_map(cls, data, dist = None):
        if isinstance(data, dict):
            data = data.items()
        else:
            data = split_sections(data)
        maps = { }
        for group, lines in data:
            if group is None:
                if not lines:
                    continue

                raise ValueError('Entry points must be listed in groups')
            group is None
            group = group.strip()
            if group in maps:
                raise ValueError('Duplicate group name', group)
            group in maps
            maps[group] = cls.parse_group(group, lines, dist)

        return maps

    parse_map = classmethod(parse_map)


class Distribution(object):

    def __init__(self, location = None, metadata = None, project_name = None, version = None, py_version = PY_MAJOR, platform = None, precedence = EGG_DIST):
        if not project_name:
            pass
        self.project_name = safe_name('Unknown')
        if version is not None:
            self._version = safe_version(version)

        self.py_version = py_version
        self.platform = platform
        self.location = location
        self.precedence = precedence
        if not metadata:
            pass
        self._provider = empty_provider


    def from_location(cls, location, basename, metadata = None, **kw):
        (project_name, version, py_version, platform) = [
            None] * 4
        (basename, ext) = os.path.splitext(basename)
        if ext.lower() in ('.egg', '.egg-info'):
            match = EGG_NAME(basename)
            if match:
                (project_name, version, py_version, platform) = match.group('name', 'ver', 'pyver', 'plat')


        return cls(location, metadata, project_name = project_name, version = version, py_version = py_version, platform = platform, **kw)

    from_location = classmethod(from_location)
    hashcmp = property((lambda self: if not self.location:
pass(getattr(self, 'parsed_version', ()), self.precedence, self.key, -len(''), self.location, self.py_version, self.platform)))

    def __cmp__(self, other):
        return cmp(self.hashcmp, other)


    def __hash__(self):
        return hash(self.hashcmp)


    def key(self):

        try:
            return self._key
        except AttributeError:
            self._key = key = self.project_name.lower()
            return key


    key = property(key)

    def parsed_version(self):

        try:
            return self._parsed_version
        except AttributeError:
            self._parsed_version = pv = parse_version(self.version)
            return pv


    parsed_version = property(parsed_version)

    def version(self):

        try:
            return self._version
        except AttributeError:
            for line in self._get_metadata('PKG-INFO'):
                if line.lower().startswith('version:'):
                    self._version = safe_version(line.split(':', 1)[1].strip())
                    return self._version
            else:
                raise ValueError("Missing 'Version:' header and/or PKG-INFO file", self)
            line.lower().startswith('version:')


    version = property(version)

    def _dep_map(self):

        try:
            return self._Distribution__dep_map
        except AttributeError:
            dm = self._Distribution__dep_map = {
                None: [] }
            for name in ('requires.txt', 'depends.txt'):
                for extra, reqs in split_sections(self._get_metadata(name)):
                    if extra:
                        extra = safe_extra(extra)

                    dm.setdefault(extra, []).extend(parse_requirements(reqs))


            return dm


    _dep_map = property(_dep_map)

    def requires(self, extras = ()):
        dm = self._dep_map
        deps = []
        deps.extend(dm.get(None, ()))
        for ext in extras:

            try:
                deps.extend(dm[safe_extra(ext)])
            continue
            except KeyError:
                raise UnknownExtra('%s has no such extra feature %r' % (self, ext))
                continue



        return deps


    def _get_metadata(self, name):
        if self.has_metadata(name):
            for line in self.get_metadata_lines(name):
                yield line




    def activate(self, path = None):
        if path is None:
            path = sys.path

        self.insert_on(path)
        if path is sys.path:
            fixup_namespace_packages(self.location)
            for pkg in self._get_metadata('namespace_packages.txt'):
                if pkg in sys.modules:
                    declare_namespace(pkg)
                    continue




    def egg_name(self):
        if not self.py_version:
            pass
        filename = '%s-%s-py%s' % (to_filename(self.project_name), to_filename(self.version), PY_MAJOR)
        if self.platform:
            filename += '-' + self.platform

        return filename


    def __repr__(self):
        if self.location:
            return '%s (%s)' % (self, self.location)
        return str(self)


    def __str__(self):

        try:
            version = getattr(self, 'version', None)
        except ValueError:
            version = None

        if not version:
            pass
        version = '[unknown version]'
        return '%s %s' % (self.project_name, version)


    def __getattr__(self, attr):
        if attr.startswith('_'):
            raise AttributeError, attr
        attr.startswith('_')
        return getattr(self._provider, attr)


    def from_filename(cls, filename, metadata = None, **kw):
        return cls.from_location(_normalize_cached(filename), os.path.basename(filename), metadata, **kw)

    from_filename = classmethod(from_filename)

    def as_requirement(self):
        return Requirement.parse('%s==%s' % (self.project_name, self.version))


    def load_entry_point(self, group, name):
        ep = self.get_entry_info(group, name)
        if ep is None:
            raise ImportError('Entry point %r not found' % ((group, name),))
        ep is None
        return ep.load()


    def get_entry_map(self, group = None):

        try:
            ep_map = self._ep_map
        except AttributeError:
            ep_map = self._ep_map = EntryPoint.parse_map(self._get_metadata('entry_points.txt'), self)

        if group is not None:
            return ep_map.get(group, { })
        return ep_map


    def get_entry_info(self, group, name):
        return self.get_entry_map(group).get(name)


    def insert_on(self, path, loc = None):
        if not loc:
            pass
        loc = self.location
        if not loc:
            return None
        nloc = _normalize_cached(loc)
        bdir = os.path.dirname(nloc)
        npath = [ p for p in path ]
        bp = None
        for p, item in enumerate(npath):
            if item == nloc:
                break
                continue
            []
            if item == bdir and self.precedence == EGG_DIST:
                path.insert(p, loc)
                npath.insert(p, nloc)
                break
                continue
            None if path is sys.path else loc
        elif path is sys.path:
            self.check_version_conflict()

        path.append(loc)
        return None
        while None:

            try:
                np = npath.index(nloc, p + 1)
            except ValueError:
                break
                continue

            del npath[np]
            del path[np]
            p = np
            continue
            return None


    def check_version_conflict(self):
        if self.key == 'setuptools':
            return None
        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
        loc = normalize_path(self.location)
        for modname in self._get_metadata('top_level.txt'):
            if modname not in sys.modules and modname in nsp or modname in _namespace_packages:
                continue

            fn = getattr(sys.modules[modname], '__file__', None)
            if fn:
                if normalize_path(fn).startswith(loc) or fn.startswith(loc):
                    continue

            issue_warning('Module %s was already imported from %s, but %s is being added to sys.path' % (modname, fn, self.location))



    def has_version(self):

        try:
            self.version
        except ValueError:
            issue_warning('Unbuilt egg for ' + repr(self))
            return False

        return True


    def clone(self, **kw):
        for attr in ('project_name', 'version', 'py_version', 'platform', 'location', 'precedence'):
            kw.setdefault(attr, getattr(self, attr, None))

        kw.setdefault('metadata', self._provider)
        return self.__class__(**kw)


    def extras(self):
        return _[1]

    extras = property(extras)


def issue_warning(*args, **kw):
    level = 1
    g = globals()

    try:
        while sys._getframe(level).f_globals is g:
            level += 1
    except ValueError:
        pass

    warn = warn
    import warnings
    warn(stacklevel = level + 1, *args, **kw)


def parse_requirements(strs):
    lines = iter(yield_lines(strs))

    def scan_list(ITEM, TERMINATOR, line, p, groups, item_name):
        items = []
        while not TERMINATOR(line, p):
            if CONTINUE(line, p):

                try:
                    line = lines.next()
                    p = 0
                except StopIteration:
                    raise ValueError('\\ must not appear on the last nonblank line')
                except:
                    None<EXCEPTION MATCH>StopIteration


            None<EXCEPTION MATCH>StopIteration
            match = ITEM(line, p)
            if not match:
                raise ValueError('Expected ' + item_name + ' in', line, 'at', line[p:])
            match
            items.append(match.group(*groups))
            p = match.end()
            match = COMMA(line, p)
            if match:
                p = match.end()
                continue
            if not TERMINATOR(line, p):
                raise ValueError("Expected ',' or end-of-list in", line, 'at', line[p:])
            TERMINATOR(line, p)
        match = TERMINATOR(line, p)
        if match:
            p = match.end()

        return (line, p, items)

    for line in lines:
        match = DISTRO(line)
        if not match:
            raise ValueError('Missing distribution spec', line)
        match
        project_name = match.group(1)
        p = match.end()
        extras = []
        match = OBRACKET(line, p)
        if match:
            p = match.end()
            (line, p, extras) = scan_list(DISTRO, CBRACKET, line, p, (1,), "'extra' name")

        (line, p, specs) = scan_list(VERSION, LINE_END, line, p, (1, 2), 'version spec')
        specs = [ (op, safe_version(val)) for op, val in specs ]
        yield Requirement(project_name, specs, extras)
        []



def _sort_dists(dists):
    tmp = [ (dist.hashcmp, dist) for dist in dists ]
    tmp.sort()
    dists[::-1] = [ d for hc, d in tmp ]


class Requirement:

    def __init__(self, project_name, specs, extras):
        self.unsafe_name = project_name
        project_name = safe_name(project_name)
        self.project_name = project_name
        self.key = project_name.lower()
        index = [ (parse_version(v), state_machine[op], op, v) for op, v in specs ]
        index.sort()
        self.specs = [ (op, ver) for parsed, trans, op, ver in index ]
        self.index = index
        self.extras = tuple(map(safe_extra, extras))
        self.hashCmp = ([], []([ (op, parsed) for parsed, trans, op, ver in index ]), frozenset(self.extras))
        self._Requirement__hash = hash(self.hashCmp)


    def __str__(self):
        specs = []([ ''.join(s) for s in self.specs ])
        extras = ','.join(self.extras)
        return '%s%s%s' % (self.project_name, extras, specs)


    def __eq__(self, other):
        if isinstance(other, Requirement):
            pass
        return self.hashCmp == other.hashCmp


    def __contains__(self, item):
        if isinstance(item, Distribution):
            if item.key != self.key:
                return False
            if self.index:
                item = item.parsed_version

        elif isinstance(item, basestring):
            item = parse_version(item)

        last = None
        for parsed, trans, op, ver in self.index:
            action = trans[cmp(item, parsed)]
            if action == 'F':
                return False
            if action == 'T':
                return True
            if action == '+':
                last = True
                continue
            action == 'T'
            if action == '-' or last is None:
                last = False
                continue
            action == 'F'

        if last is None:
            last = True

        return last


    def __hash__(self):
        return self._Requirement__hash


    def __repr__(self):
        return 'Requirement.parse(%r)' % str(self)


    def parse(s):
        reqs = list(parse_requirements(s))
        if reqs:
            if len(reqs) == 1:
                return reqs[0]
            raise ValueError('Expected only one requirement', s)
        reqs
        raise ValueError('No requirements found', s)

    parse = staticmethod(parse)

state_machine = {
    '<': '--T',
    '<=': 'T-T',
    '>': 'F+F',
    '>=': 'T+F',
    '==': 'T..',
    '!=': 'F++' }

def _get_mro(cls):
    if not isinstance(cls, type):

        class cls(cls, object):
            pass

        return cls.__mro__[1:]
    return cls.__mro__


def _find_adapter(registry, ob):
    for t in _get_mro(getattr(ob, '__class__', type(ob))):
        if t in registry:
            return registry[t]



def ensure_directory(path):
    dirname = os.path.dirname(path)
    if not os.path.isdir(dirname):
        os.makedirs(dirname)



def split_sections(s):
    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)
        line.endswith(']')
        content.append(line)

    yield (section, content)


def _mkstemp(*args, **kw):
    mkstemp = mkstemp
    import tempfile
    old_open = os.open

    try:
        os.open = os_open
        return mkstemp(*args, **kw)
    finally:
        os.open = old_open


_manager = ResourceManager()

def _initialize(g):
    for name in dir(_manager):
        if not name.startswith('_'):
            g[name] = getattr(_manager, name)
            continue


_initialize(globals())
_declare_state('object', working_set = WorkingSet())

try:
    from __main__ import __requires__
except ImportError:
    pass


try:
    working_set.require(__requires__)
except VersionConflict:
    working_set = WorkingSet([])
    for dist in working_set.resolve(parse_requirements(__requires__), Environment()):
        working_set.add(dist)

    for entry in sys.path:
        if entry not in working_set.entries:
            working_set.add_entry(entry)


    sys.path[:] = working_set.entries

require = working_set.require
iter_entry_points = working_set.iter_entry_points
add_activation_listener = working_set.subscribe
run_script = working_set.run_script
run_main = run_script
add_activation_listener((lambda dist: dist.activate()))
working_set.entries = []
map(working_set.add_entry, sys.path)