Gecko [ beriskala.com ]

Name	Size	Permission	Date
_code	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
_io	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
_log	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
_path	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
_process	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
__init__.py	5.94 KB	-rw-r--r--	2019-10-22 06:31
__init__.pyc	4.9 KB	-rw-r--r--	2019-10-22 06:31
__init__.pyo	4.9 KB	-rw-r--r--	2019-10-22 06:31
__metainfo.py	57 B	-rw-r--r--	2019-10-22 06:31
__metainfo.pyc	256 B	-rw-r--r--	2019-10-22 06:31
__metainfo.pyo	256 B	-rw-r--r--	2019-10-22 06:31
_apipkg.py	5.89 KB	-rw-r--r--	2019-10-22 06:31
_apipkg.pyc	6.65 KB	-rw-r--r--	2019-10-22 06:31
_apipkg.pyo	6.65 KB	-rw-r--r--	2019-10-22 06:31
_builtin.py	6.61 KB	-rw-r--r--	2019-10-22 06:31
_builtin.pyc	9.12 KB	-rw-r--r--	2019-10-22 06:31
_builtin.pyo	9.04 KB	-rw-r--r--	2019-10-22 06:31
_error.py	2.86 KB	-rw-r--r--	2019-10-22 06:31
_error.pyc	3.26 KB	-rw-r--r--	2019-10-22 06:31
_error.pyo	3.26 KB	-rw-r--r--	2019-10-22 06:31
_iniconfig.py	5.23 KB	-rw-r--r--	2019-10-22 06:31
_iniconfig.pyc	6.76 KB	-rw-r--r--	2019-10-22 06:31
_iniconfig.pyo	6.76 KB	-rw-r--r--	2019-10-22 06:31
_std.py	433 B	-rw-r--r--	2019-10-22 06:31
_std.pyc	1.02 KB	-rw-r--r--	2019-10-22 06:31
_std.pyo	1.02 KB	-rw-r--r--	2019-10-22 06:31
_xmlgen.py	8.42 KB	-rw-r--r--	2019-10-22 06:31
_xmlgen.pyc	12.33 KB	-rw-r--r--	2019-10-22 06:31
_xmlgen.pyo	12.25 KB	-rw-r--r--	2019-10-22 06:31
test.py	232 B	-rw-r--r--	2019-10-22 06:31
test.pyc	340 B	-rw-r--r--	2019-10-22 06:31
test.pyo	340 B	-rw-r--r--	2019-10-22 06:31

Rename

"""
apipkg: control the exported namespace of a python package.

see http://pypi.python.org/pypi/apipkg

__version__ = '1.3.dev'

def _py_abspath(path):
    """
    special version of abspath
    that will leave paths from jython jars alone
    """
    if path.startswith('__pyclasspath__'):

return path
    else:
        return os.path.abspath(path)

def initpkg(pkgname, exportdefs, attr=dict()):
    """ initialize given package from the export definitions. """
    oldmod = sys.modules.get(pkgname)
    d = {}
    f = getattr(oldmod, '__file__', None)
    if f:
        f = _py_abspath(f)
    d['__file__'] = f
    if hasattr(oldmod, '__version__'):
        d['__version__'] = oldmod.__version__
    if hasattr(oldmod, '__loader__'):
        d['__loader__'] = oldmod.__loader__
    if hasattr(oldmod, '__path__'):
        d['__path__'] = [_py_abspath(p) for p in oldmod.__path__]
    if '__doc__' not in exportdefs and getattr(oldmod, '__doc__', None):
        d['__doc__'] = oldmod.__doc__
    d.update(attr)
    if hasattr(oldmod, "__dict__"):
        oldmod.__dict__.update(d)
    mod = ApiModule(pkgname, exportdefs, implprefix=pkgname, attr=d)
    sys.modules[pkgname] = mod

def importobj(modpath, attrname):
    module = __import__(modpath, None, None, ['__doc__'])
    if not attrname:
        return module

retval = module
    names = attrname.split(".")
    for x in names:
        retval = getattr(retval, x)
    return retval

class ApiModule(ModuleType):
    def __docget(self):
        try:
            return self.__doc
        except AttributeError:
            if '__doc__' in self.__map__:
                return self.__makeattr('__doc__')
    def __docset(self, value):
        self.__doc = value
    __doc__ = property(__docget, __docset)

def __init__(self, name, importspec, implprefix=None, attr=None):
        self.__name__ = name
        self.__all__ = [x for x in importspec if x != '__onfirstaccess__']
        self.__map__ = {}
        self.__implprefix__ = implprefix or name
        if attr:
            for name, val in attr.items():
                # print "setting", self.__name__, name, val
                setattr(self, name, val)
        for name, importspec in importspec.items():
            if isinstance(importspec, dict):
                subname = '%s.%s' % (self.__name__, name)
                apimod = ApiModule(subname, importspec, implprefix)
                sys.modules[subname] = apimod
                setattr(self, name, apimod)
            else:
                parts = importspec.split(':')
                modpath = parts.pop(0)
                attrname = parts and parts[0] or ""
                if modpath[0] == '.':
                    modpath = implprefix + modpath

if not attrname:
                    subname = '%s.%s' % (self.__name__, name)
                    apimod = AliasModule(subname, modpath)
                    sys.modules[subname] = apimod
                    if '.' not in name:
                        setattr(self, name, apimod)
                else:
                    self.__map__[name] = (modpath, attrname)

def __repr__(self):
        l = []
        if hasattr(self, '__version__'):
            l.append("version=" + repr(self.__version__))
        if hasattr(self, '__file__'):
            l.append('from ' + repr(self.__file__))
        if l:
            return '<ApiModule %r %s>' % (self.__name__, " ".join(l))
        return '<ApiModule %r>' % (self.__name__,)

def __makeattr(self, name):
        """lazily compute value for name or raise AttributeError if unknown."""
        # print "makeattr", self.__name__, name
        target = None
        if '__onfirstaccess__' in self.__map__:
            target = self.__map__.pop('__onfirstaccess__')
            importobj(*target)()
        try:
            modpath, attrname = self.__map__[name]
        except KeyError:
            if target is not None and name != '__onfirstaccess__':
                # retry, onfirstaccess might have set attrs
                return getattr(self, name)
            raise AttributeError(name)
        else:
            result = importobj(modpath, attrname)
            setattr(self, name, result)
            try:
                del self.__map__[name]
            except KeyError:
                pass  # in a recursive-import situation a double-del can happen
            return result

__getattr__ = __makeattr

def __dict__(self):
        # force all the content of the module to be loaded when __dict__ is read
        dictdescr = ModuleType.__dict__['__dict__']
        dict = dictdescr.__get__(self)
        if dict is not None:
            hasattr(self, 'some')
            for name in self.__all__:
                try:
                    self.__makeattr(name)
                except AttributeError:
                    pass
        return dict
    __dict__ = property(__dict__)

def AliasModule(modname, modpath, attrname=None):
    mod = []

def getmod():
        if not mod:
            x = importobj(modpath, None)
            if attrname is not None:
                x = getattr(x, attrname)
            mod.append(x)
        return mod[0]

class AliasModule(ModuleType):

def __repr__(self):
            x = modpath
            if attrname:
                x += "." + attrname
            return '<AliasModule %r for %r>' % (modname, x)

def __getattribute__(self, name):
            try:
                return getattr(getmod(), name)
            except ImportError:
                return None

def __setattr__(self, name, value):
            setattr(getmod(), name, value)

def __delattr__(self, name):
            delattr(getmod(), name)

return AliasModule(str(modname))