From e97ecf97053b1fdd2c978713b9879d6438aaf207 Mon Sep 17 00:00:00 2001 From: Greg Stein Date: Thu, 29 Jun 2000 11:05:30 +0000 Subject: [PATCH] demonstration importers --- Demo/imputil/importers.py | 248 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 Demo/imputil/importers.py diff --git a/Demo/imputil/importers.py b/Demo/imputil/importers.py new file mode 100644 index 00000000000..cfb2dafe5e4 --- /dev/null +++ b/Demo/imputil/importers.py @@ -0,0 +1,248 @@ +# +# importers.py +# +# Demonstration subclasses of imputil.Importer +# + +# There should be consideration for the imports below if it is desirable +# to have "all" modules be imported through the imputil system. + +# these are C extensions +import sys +import imp +import struct +import marshal + +# these are .py modules +import imputil +import os + +###################################################################### + +_TupleType = type(()) +_StringType = type('') + +###################################################################### + +# byte-compiled file suffic character +_suffix_char = __debug__ and 'c' or 'o' + +# byte-compiled file suffix +_suffix = '.py' + _suffix_char + +# the C_EXTENSION suffixes +_c_suffixes = filter(lambda x: x[2] == imp.C_EXTENSION, imp.get_suffixes()) + +def _timestamp(pathname): + "Return the file modification time as a Long." + try: + s = os.stat(pathname) + except OSError: + return None + return long(s[8]) + +def _fs_import(dir, modname, fqname): + "Fetch a module from the filesystem." + + pathname = os.path.join(dir, modname) + if os.path.isdir(pathname): + values = { '__pkgdir__' : pathname, '__path__' : [ pathname ] } + ispkg = 1 + pathname = os.path.join(pathname, '__init__') + else: + values = { } + ispkg = 0 + + # look for dynload modules + for desc in _c_suffixes: + file = pathname + desc[0] + try: + fp = open(file, desc[1]) + except IOError: + pass + else: + module = imp.load_module(fqname, fp, file, desc) + values['__file__'] = file + return 0, module, values + + t_py = _timestamp(pathname + '.py') + t_pyc = _timestamp(pathname + _suffix) + 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): + file = pathname + _suffix + f = open(file, 'rb') + if f.read(4) == imp.get_magic(): + t = struct.unpack('., where + can be located using a subclass-specific mechanism and the + is found in the archive using a subclass-specific mechanism. + + This class defines two hooks for subclasses: one to locate an archive + (and possibly return some context for future subfile lookups), and one + to locate subfiles. + """ + + def get_code(self, parent, modname, fqname): + if parent: + # the Importer._finish_import logic ensures that we handle imports + # under the top level module (package / archive). + assert parent.__importer__ == self + + # 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 isinstance(result, _TupleType): + assert len(result) == 2 + 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(imputil.Importer): + "Importer subclass to emulate the standard importer." + + def __init__(self, dir): + self.dir = dir + + def get_code(self, parent, modname, fqname): + if parent: + dir = parent.__pkgdir__ + else: + dir = self.dir + + # Return the module (and other info) if found in the specified + # directory. Otherwise, return None. + return _fs_import(dir, modname, fqname) + + def __repr__(self): + return '<%s.%s for "%s" at 0x%x>' % (self.__class__.__module__, + self.__class__.__name__, + self.dir, + id(self)) + + +###################################################################### +# +# Emulate the standard path-style import mechanism +# +class PathImporter(imputil.Importer): + def __init__(self, path=sys.path): + self.path = path + + def get_code(self, parent, modname, fqname): + if parent: + # we are looking for a module inside of a specific package + return _fs_import(parent.__pkgdir__, modname, fqname) + + # scan sys.path, looking for the requested module + for dir in self.path: + if isinstance(dir, _StringType): + result = _fs_import(dir, modname, fqname) + if result: + return result + + # not found + return None + +###################################################################### + +def _test_dir(): + "Debug/test function to create DirectoryImporters from sys.path." + imputil.ImportManager().install() + path = sys.path[:] + path.reverse() + for d in path: + sys.path.insert(0, DirectoryImporter(d)) + sys.path.insert(0, imputil.BuiltinImporter()) + +def _test_revamp(): + "Debug/test function for the revamped import system." + imputil.ImportManager().install() + sys.path.insert(0, PathImporter()) + sys.path.insert(0, imputil.BuiltinImporter())