initial checkin for my Python stuff.
This commit is contained in:
parent
e168c65603
commit
281b8d82f7
|
@ -0,0 +1,492 @@
|
|||
#
|
||||
# imputil.py
|
||||
#
|
||||
# Written by Greg Stein. Public Domain.
|
||||
# No Copyright, no Rights Reserved, and no Warranties.
|
||||
#
|
||||
# Utilities to help out with custom import mechanisms.
|
||||
#
|
||||
# Additional modifications were contribed by Marc-Andre Lemburg and
|
||||
# Gordon McMillan.
|
||||
#
|
||||
|
||||
__version__ = '0.3'
|
||||
|
||||
# note: avoid importing non-builtin modules
|
||||
import imp
|
||||
import sys
|
||||
import strop
|
||||
import __builtin__ ### why this instead of just using __builtins__ ??
|
||||
|
||||
# for the DirectoryImporter
|
||||
import struct
|
||||
import marshal
|
||||
|
||||
class Importer:
|
||||
"Base class for replacing standard import functions."
|
||||
|
||||
def install(self):
|
||||
self.__chain_import = __builtin__.__import__
|
||||
self.__chain_reload = __builtin__.reload
|
||||
__builtin__.__import__ = self._import_hook
|
||||
__builtin__.reload = self._reload_hook
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# PRIVATE METHODS
|
||||
#
|
||||
def _import_hook(self, name, globals=None, locals=None, fromlist=None):
|
||||
"""Python calls this hook to locate and import a module.
|
||||
|
||||
This method attempts to load the (dotted) module name. If it cannot
|
||||
find it, then it delegates the import to the next import hook in the
|
||||
chain (where "next" is defined as the import hook that was in place
|
||||
at the time this Importer instance was installed).
|
||||
"""
|
||||
|
||||
### insert a fast-path check for whether the module is already
|
||||
### loaded? use a variant of _determine_import_context() which
|
||||
### returns a context regardless of Importer used. generate an
|
||||
### fqname and look in sys.modules for it.
|
||||
|
||||
# determine the context of this import
|
||||
parent = self._determine_import_context(globals)
|
||||
|
||||
# import the module within the context, or from the default context
|
||||
top, tail = self._import_top_module(parent, name)
|
||||
if top is None:
|
||||
# the module was not found; delegate to the next import hook
|
||||
return self.__chain_import(name, globals, locals, fromlist)
|
||||
|
||||
# the top module may be under the control of a different importer.
|
||||
# if so, then defer to that importer for completion of the import.
|
||||
# note it may be self, or is undefined so we (self) may as well
|
||||
# finish the import.
|
||||
importer = top.__dict__.get('__importer__', self)
|
||||
return importer._finish_import(top, tail, fromlist)
|
||||
|
||||
def _finish_import(self, top, tail, fromlist):
|
||||
# if "a.b.c" was provided, then load the ".b.c" portion down from
|
||||
# below the top-level module.
|
||||
bottom = self._load_tail(top, tail)
|
||||
|
||||
# if the form is "import a.b.c", then return "a"
|
||||
if not fromlist:
|
||||
# no fromlist: return the top of the import tree
|
||||
return top
|
||||
|
||||
# the top module was imported by self, or it was not imported through
|
||||
# the Importer mechanism and self is simply handling the import of
|
||||
# the sub-modules and fromlist.
|
||||
#
|
||||
# this means that the bottom module was also imported by self, or we
|
||||
# are handling things in the absence of a prior Importer
|
||||
#
|
||||
# ### why the heck are we handling it? what is the example scenario
|
||||
# ### where this happens? note that we can't determine is_package()
|
||||
# ### for non-Importer modules.
|
||||
#
|
||||
# since we imported/handled the bottom module, this means that we can
|
||||
# also handle its fromlist (and reliably determine is_package()).
|
||||
|
||||
# if the bottom node is a package, then (potentially) import some modules.
|
||||
#
|
||||
# note: if it is not a package, then "fromlist" refers to names in
|
||||
# the bottom module rather than modules.
|
||||
# note: for a mix of names and modules in the fromlist, we will
|
||||
# import all modules and insert those into the namespace of
|
||||
# the package module. Python will pick up all fromlist names
|
||||
# from the bottom (package) module; some will be modules that
|
||||
# we imported and stored in the namespace, others are expected
|
||||
# to be present already.
|
||||
if self._is_package(bottom.__dict__):
|
||||
self._import_fromlist(bottom, fromlist)
|
||||
|
||||
# if the form is "from a.b import c, d" then return "b"
|
||||
return bottom
|
||||
|
||||
def _reload_hook(self, module):
|
||||
"Python calls this hook to reload a module."
|
||||
|
||||
# reloading of a module may or may not be possible (depending on the
|
||||
# importer), but at least we can validate that it's ours to reload
|
||||
importer = module.__dict__.get('__importer__', None)
|
||||
if importer is not self:
|
||||
return self.__chain_reload(module)
|
||||
|
||||
# okay. it is ours, but we don't know what to do (yet)
|
||||
### we should blast the module dict and do another get_code(). need to
|
||||
### flesh this out and add proper docco...
|
||||
raise SystemError, "reload not yet implemented"
|
||||
|
||||
def _determine_import_context(self, globals):
|
||||
"""Returns the context in which a module should be imported.
|
||||
|
||||
The context could be a loaded (package) module and the imported module
|
||||
will be looked for within that package. The context could also be None,
|
||||
meaning there is no context -- the module should be looked for as a
|
||||
"top-level" module.
|
||||
"""
|
||||
|
||||
if not globals or \
|
||||
globals.get('__importer__', None) is not self:
|
||||
# globals does not refer to one of our modules or packages.
|
||||
# That implies there is no relative import context, and it
|
||||
# should just pick it off the standard path.
|
||||
return None
|
||||
|
||||
# The globals refer to a module or package of ours. It will define
|
||||
# the context of the new import. Get the module/package fqname.
|
||||
parent_fqname = globals['__name__']
|
||||
|
||||
# for a package, return itself (imports refer to pkg contents)
|
||||
if self._is_package(globals):
|
||||
parent = sys.modules[parent_fqname]
|
||||
assert globals is parent.__dict__
|
||||
return parent
|
||||
|
||||
i = strop.rfind(parent_fqname, '.')
|
||||
|
||||
# a module outside of a package has no particular import context
|
||||
if i == -1:
|
||||
return None
|
||||
|
||||
# for a module in a package, return the package (imports refer to siblings)
|
||||
parent_fqname = parent_fqname[:i]
|
||||
parent = sys.modules[parent_fqname]
|
||||
assert parent.__name__ == parent_fqname
|
||||
return parent
|
||||
|
||||
def _import_top_module(self, parent, name):
|
||||
"""Locate the top of the import tree (relative or absolute).
|
||||
|
||||
parent defines the context in which the import should occur. See
|
||||
_determine_import_context() for details.
|
||||
|
||||
Returns a tuple (module, tail). module is the loaded (top-level) module,
|
||||
or None if the module is not found. tail is the remaining portion of
|
||||
the dotted name.
|
||||
"""
|
||||
i = strop.find(name, '.')
|
||||
if i == -1:
|
||||
head = name
|
||||
tail = ""
|
||||
else:
|
||||
head = name[:i]
|
||||
tail = name[i+1:]
|
||||
if parent:
|
||||
fqname = "%s.%s" % (parent.__name__, head)
|
||||
else:
|
||||
fqname = head
|
||||
module = self._import_one(parent, head, fqname)
|
||||
if module:
|
||||
# the module was relative, or no context existed (the module was
|
||||
# simply found on the path).
|
||||
return module, tail
|
||||
if parent:
|
||||
# we tried relative, now try an absolute import (from the path)
|
||||
module = self._import_one(None, head, head)
|
||||
if module:
|
||||
return module, tail
|
||||
|
||||
# the module wasn't found
|
||||
return None, None
|
||||
|
||||
def _import_one(self, parent, modname, fqname):
|
||||
"Import a single module."
|
||||
|
||||
# has the module already been imported?
|
||||
try:
|
||||
return sys.modules[fqname]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
# load the module's code, or fetch the module itself
|
||||
result = self.get_code(parent, modname, fqname)
|
||||
if result is None:
|
||||
return None
|
||||
|
||||
# did get_code() return an actual module? (rather than a code object)
|
||||
is_module = type(result[1]) is type(sys)
|
||||
|
||||
# use the returned module, or create a new one to exec code into
|
||||
if is_module:
|
||||
module = result[1]
|
||||
else:
|
||||
module = imp.new_module(fqname)
|
||||
|
||||
### record packages a bit differently??
|
||||
module.__importer__ = self
|
||||
module.__ispkg__ = result[0]
|
||||
|
||||
# if present, the third item is a set of values to insert into the module
|
||||
if len(result) > 2:
|
||||
module.__dict__.update(result[2])
|
||||
|
||||
# the module is almost ready... make it visible
|
||||
sys.modules[fqname] = module
|
||||
|
||||
# execute the code within the module's namespace
|
||||
if not is_module:
|
||||
exec result[1] in module.__dict__
|
||||
|
||||
# insert the module into its parent
|
||||
if parent:
|
||||
setattr(parent, modname, module)
|
||||
return module
|
||||
|
||||
def _load_tail(self, m, tail):
|
||||
"""Import the rest of the modules, down from the top-level module.
|
||||
|
||||
Returns the last module in the dotted list of modules.
|
||||
"""
|
||||
if tail:
|
||||
for part in strop.splitfields(tail, '.'):
|
||||
fqname = "%s.%s" % (m.__name__, part)
|
||||
m = self._import_one(m, part, fqname)
|
||||
if not m:
|
||||
raise ImportError, "No module named " + fqname
|
||||
return m
|
||||
|
||||
def _import_fromlist(self, package, fromlist):
|
||||
'Import any sub-modules in the "from" list.'
|
||||
|
||||
# if '*' is present in the fromlist, then look for the '__all__' variable
|
||||
# to find additional items (modules) to import.
|
||||
if '*' in fromlist:
|
||||
fromlist = list(fromlist) + list(package.__dict__.get('__all__', []))
|
||||
|
||||
for sub in fromlist:
|
||||
# if the name is already present, then don't try to import it (it
|
||||
# might not be a module!).
|
||||
if sub != '*' and not hasattr(package, sub):
|
||||
subname = "%s.%s" % (package.__name__, sub)
|
||||
submod = self._import_one(package, sub, subname)
|
||||
if not submod:
|
||||
raise ImportError, "cannot import name " + subname
|
||||
|
||||
def _is_package(self, module_dict):
|
||||
"""Determine if a given module (dictionary) specifies a package.
|
||||
|
||||
The package status is in the module-level name __ispkg__. The module
|
||||
must also have been imported by self, so that we can reliably apply
|
||||
semantic meaning to __ispkg__.
|
||||
|
||||
### weaken the test to issubclass(Importer)?
|
||||
"""
|
||||
return module_dict.get('__importer__', None) is self and \
|
||||
module_dict['__ispkg__']
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# METHODS TO OVERRIDE
|
||||
#
|
||||
def get_code(self, parent, modname, fqname):
|
||||
"""Find and retrieve the code for the given module.
|
||||
|
||||
parent specifies a parent module to define a context for importing. It
|
||||
may be None, indicating no particular context for the search.
|
||||
|
||||
modname specifies a single module (not dotted) within the parent.
|
||||
|
||||
fqname specifies the fully-qualified module name. This is a (potentially)
|
||||
dotted name from the "root" of the module namespace down to the modname.
|
||||
If there is no parent, then modname==fqname.
|
||||
|
||||
This method should return None, a 2-tuple, or a 3-tuple.
|
||||
|
||||
* If the module was not found, then None should be returned.
|
||||
|
||||
* The first item of the 2- or 3-tuple should be the integer 0 or 1,
|
||||
specifying whether the module that was found is a package or not.
|
||||
|
||||
* The second item is the code object for the module (it will be
|
||||
executed within the new module's namespace). This item can also
|
||||
be a fully-loaded module object (e.g. loaded from a shared lib).
|
||||
|
||||
* If present, the third item is a dictionary of name/value pairs that
|
||||
will be inserted into new module before the code object is executed.
|
||||
This provided in case the module's code expects certain values (such
|
||||
as where the module was found). When the second item is a module
|
||||
object, then these names/values will be inserted *after* the module
|
||||
has been loaded/initialized.
|
||||
"""
|
||||
raise RuntimeError, "get_code not implemented"
|
||||
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# Simple function-based importer
|
||||
#
|
||||
class FuncImporter(Importer):
|
||||
"Importer subclass to use a supplied function rather than method overrides."
|
||||
def __init__(self, func):
|
||||
self.func = func
|
||||
def get_code(self, parent, modname, fqname):
|
||||
return self.func(parent, modname, fqname)
|
||||
|
||||
def install_with(func):
|
||||
FuncImporter(func).install()
|
||||
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# Base class for archive-based importing
|
||||
#
|
||||
class PackageArchiveImporter(Importer):
|
||||
"Importer subclass to import from (file) archives."
|
||||
|
||||
def get_code(self, parent, modname, fqname):
|
||||
if parent:
|
||||
# if a parent "package" is provided, then we are importing a sub-file
|
||||
# from the archive.
|
||||
result = self.get_subfile(parent.__archive__, modname)
|
||||
if result is None:
|
||||
return None
|
||||
if type(result) == type(()):
|
||||
return (0,) + result
|
||||
return 0, result
|
||||
|
||||
# no parent was provided, so the archive should exist somewhere on the
|
||||
# default "path".
|
||||
archive = self.get_archive(modname)
|
||||
if archive is None:
|
||||
return None
|
||||
return 1, "", {'__archive__':archive}
|
||||
|
||||
def get_archive(self, modname):
|
||||
"""Get an archive of modules.
|
||||
|
||||
This method should locate an archive and return a value which can be
|
||||
used by get_subfile to load modules from it. The value may be a simple
|
||||
pathname, an open file, or a complex object that caches information
|
||||
for future imports.
|
||||
|
||||
Return None if the archive was not found.
|
||||
"""
|
||||
raise RuntimeError, "get_archive not implemented"
|
||||
|
||||
def get_subfile(self, archive, modname):
|
||||
"""Get code from a subfile in the specified archive.
|
||||
|
||||
Given the specified archive (as returned by get_archive()), locate
|
||||
and return a code object for the specified module name.
|
||||
|
||||
A 2-tuple may be returned, consisting of a code object and a dict
|
||||
of name/values to place into the target module.
|
||||
|
||||
Return None if the subfile was not found.
|
||||
"""
|
||||
raise RuntimeError, "get_subfile not implemented"
|
||||
|
||||
|
||||
class PackageArchive(PackageArchiveImporter):
|
||||
"PackageArchiveImporter subclass that refers to a specific archive."
|
||||
|
||||
def __init__(self, modname, archive_pathname):
|
||||
self.__modname = modname
|
||||
self.__path = archive_pathname
|
||||
|
||||
def get_archive(self, modname):
|
||||
if modname == self.__modname:
|
||||
return self.__path
|
||||
return None
|
||||
|
||||
# get_subfile is passed the full pathname of the archive
|
||||
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# Emulate the standard directory-based import mechanism
|
||||
#
|
||||
|
||||
class DirectoryImporter(Importer):
|
||||
"Importer subclass to emulate the standard importer."
|
||||
|
||||
def __init__(self, dir):
|
||||
self.dir = dir
|
||||
self.ext_char = __debug__ and 'c' or 'o'
|
||||
self.ext = '.py' + self.ext_char
|
||||
|
||||
def get_code(self, parent, modname, fqname):
|
||||
if parent:
|
||||
dir = parent.__pkgdir__
|
||||
else:
|
||||
dir = self.dir
|
||||
|
||||
# pull the os module from our instance data. we don't do this at the
|
||||
# top-level, because it isn't a builtin module (and we want to defer
|
||||
# loading non-builtins until as late as possible).
|
||||
try:
|
||||
os = self.os
|
||||
except AttributeError:
|
||||
import os
|
||||
self.os = os
|
||||
|
||||
pathname = os.path.join(dir, modname)
|
||||
if os.path.isdir(pathname):
|
||||
values = { '__pkgdir__' : pathname }
|
||||
ispkg = 1
|
||||
pathname = os.path.join(pathname, '__init__')
|
||||
else:
|
||||
values = { }
|
||||
ispkg = 0
|
||||
|
||||
t_py = self._timestamp(pathname + '.py')
|
||||
t_pyc = self._timestamp(pathname + self.ext)
|
||||
if t_py is None and t_pyc is None:
|
||||
return None
|
||||
code = None
|
||||
if t_py is None or (t_pyc is not None and t_pyc >= t_py):
|
||||
f = open(pathname + self.ext, 'rb')
|
||||
if f.read(4) == imp.get_magic():
|
||||
t = struct.unpack('<I', f.read(4))[0]
|
||||
if t == t_py:
|
||||
code = marshal.load(f)
|
||||
f.close()
|
||||
if code is None:
|
||||
code = self._compile(pathname + '.py', t_py)
|
||||
return ispkg, code, values
|
||||
|
||||
def _timestamp(self, pathname):
|
||||
try:
|
||||
s = self.os.stat(pathname)
|
||||
except OSError:
|
||||
return None
|
||||
return long(s[8])
|
||||
|
||||
def _compile(self, pathname, timestamp):
|
||||
codestring = open(pathname, 'r').read()
|
||||
if codestring and codestring[-1] != '\n':
|
||||
codestring = codestring + '\n'
|
||||
code = __builtin__.compile(codestring, pathname, 'exec')
|
||||
|
||||
# try to cache the compiled code
|
||||
try:
|
||||
f = open(pathname + self.ext_char, 'wb')
|
||||
f.write('\0\0\0\0')
|
||||
f.write(struct.pack('<I', timestamp))
|
||||
marshal.dump(code, f)
|
||||
f.flush()
|
||||
f.seek(0, 0)
|
||||
f.write(imp.get_magic())
|
||||
f.close()
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
return code
|
||||
|
||||
def __repr__(self):
|
||||
return '<%s.%s for "%s" at 0x%x>' % (self.__class__.__module__,
|
||||
self.__class__.__name__,
|
||||
self.dir,
|
||||
id(self))
|
||||
|
||||
def _test_dir():
|
||||
"Debug/test function to create DirectoryImporters from sys.path."
|
||||
path = sys.path[:]
|
||||
path.reverse()
|
||||
for d in path:
|
||||
DirectoryImporter(d).install()
|
||||
|
||||
######################################################################
|
Loading…
Reference in New Issue