Demo/imputil/importers.py

   1 #
   2 # importers.py
   3 #
   4 # Demonstration subclasses of imputil.Importer
   5 #
   6
   7 # There should be consideration for the imports below if it is desirable
   8 # to have "all" modules be imported through the imputil system.
   9
  10 # these are C extensions
  11 import sys
  12 import imp
  13 import struct
  14 import marshal
  15
  16 # these are .py modules
  17 import imputil
  18 import os
  19
  20 ######################################################################
  21
  22 _TupleType = type(())
  23 _StringType = type('')
  24
  25 ######################################################################
  26
  27 # byte-compiled file suffic character
  28 _suffix_char = __debug__ and 'c' or 'o'
  29
  30 # byte-compiled file suffix
  31 _suffix = '.py' + _suffix_char
  32
  33 # the C_EXTENSION suffixes
  34 _c_suffixes = filter(lambda x: x[2] == imp.C_EXTENSION, imp.get_suffixes())
  35
  36 def _timestamp(pathname):
  37     "Return the file modification time as a Long."
  38     try:
  39         s = os.stat(pathname)
  40     except OSError:
  41         return None
  42     return long(s[8])
  43
  44 def _fs_import(dir, modname, fqname):
  45     "Fetch a module from the filesystem."
  46
  47     pathname = os.path.join(dir, modname)
  48     if os.path.isdir(pathname):
  49         values = { '__pkgdir__' : pathname, '__path__' : [ pathname ] }
  50         ispkg = 1
  51         pathname = os.path.join(pathname, '__init__')
  52     else:
  53         values = { }
  54         ispkg = 0
  55
  56         # look for dynload modules
  57         for desc in _c_suffixes:
  58             file = pathname + desc[0]
  59             try:
  60                 fp = open(file, desc[1])
  61             except IOError:
  62                 pass
  63             else:
  64                 module = imp.load_module(fqname, fp, file, desc)
  65                 values['__file__'] = file
  66                 return 0, module, values
  67
  68     t_py = _timestamp(pathname + '.py')
  69     t_pyc = _timestamp(pathname + _suffix)
  70     if t_py is None and t_pyc is None:
  71         return None
  72     code = None
  73     if t_py is None or (t_pyc is not None and t_pyc >= t_py):
  74         file = pathname + _suffix
  75         f = open(file, 'rb')
  76         if f.read(4) == imp.get_magic():
  77             t = struct.unpack('<I', f.read(4))[0]
  78             if t == t_py:
  79                 code = marshal.load(f)
  80         f.close()
  81     if code is None:
  82         file = pathname + '.py'
  83         code = _compile(file, t_py)
  84
  85     values['__file__'] = file
  86     return ispkg, code, values
  87
  88 ######################################################################
  89 #
  90 # Simple function-based importer
  91 #
  92 class FuncImporter(imputil.Importer):
  93     "Importer subclass to delegate to a function rather than method overrides."
  94     def __init__(self, func):
  95         self.func = func
  96     def get_code(self, parent, modname, fqname):
  97         return self.func(parent, modname, fqname)
  98
  99 def install_with(func):
 100     FuncImporter(func).install()
 101
 102
 103 ######################################################################
 104 #
 105 # Base class for archive-based importing
 106 #
 107 class PackageArchiveImporter(imputil.Importer):
 108     """Importer subclass to import from (file) archives.
 109
 110     This Importer handles imports of the style <archive>.<subfile>, where
 111     <archive> can be located using a subclass-specific mechanism and the
 112     <subfile> is found in the archive using a subclass-specific mechanism.
 113
 114     This class defines two hooks for subclasses: one to locate an archive
 115     (and possibly return some context for future subfile lookups), and one
 116     to locate subfiles.
 117     """
 118
 119     def get_code(self, parent, modname, fqname):
 120         if parent:
 121             # the Importer._finish_import logic ensures that we handle imports
 122             # under the top level module (package / archive).
 123             assert parent.__importer__ == self
 124
 125             # if a parent "package" is provided, then we are importing a
 126             # sub-file from the archive.
 127             result = self.get_subfile(parent.__archive__, modname)
 128             if result is None:
 129                 return None
 130             if isinstance(result, _TupleType):
 131                 assert len(result) == 2
 132                 return (0,) + result
 133             return 0, result, {}
 134
 135         # no parent was provided, so the archive should exist somewhere on the
 136         # default "path".
 137         archive = self.get_archive(modname)
 138         if archive is None:
 139             return None
 140         return 1, "", {'__archive__':archive}
 141
 142     def get_archive(self, modname):
 143         """Get an archive of modules.
 144
 145         This method should locate an archive and return a value which can be
 146         used by get_subfile to load modules from it. The value may be a simple
 147         pathname, an open file, or a complex object that caches information
 148         for future imports.
 149
 150         Return None if the archive was not found.
 151         """
 152         raise RuntimeError, "get_archive not implemented"
 153
 154     def get_subfile(self, archive, modname):
 155         """Get code from a subfile in the specified archive.
 156
 157         Given the specified archive (as returned by get_archive()), locate
 158         and return a code object for the specified module name.
 159
 160         A 2-tuple may be returned, consisting of a code object and a dict
 161         of name/values to place into the target module.
 162
 163         Return None if the subfile was not found.
 164         """
 165         raise RuntimeError, "get_subfile not implemented"
 166
 167
 168 class PackageArchive(PackageArchiveImporter):
 169     "PackageArchiveImporter subclass that refers to a specific archive."
 170
 171     def __init__(self, modname, archive_pathname):
 172         self.__modname = modname
 173         self.__path = archive_pathname
 174
 175     def get_archive(self, modname):
 176         if modname == self.__modname:
 177             return self.__path
 178         return None
 179
 180     # get_subfile is passed the full pathname of the archive
 181
 182
 183 ######################################################################
 184 #
 185 # Emulate the standard directory-based import mechanism
 186 #
 187 class DirectoryImporter(imputil.Importer):
 188     "Importer subclass to emulate the standard importer."
 189
 190     def __init__(self, dir):
 191         self.dir = dir
 192
 193     def get_code(self, parent, modname, fqname):
 194         if parent:
 195             dir = parent.__pkgdir__
 196         else:
 197             dir = self.dir
 198
 199         # Return the module (and other info) if found in the specified
 200         # directory. Otherwise, return None.
 201         return _fs_import(dir, modname, fqname)
 202
 203     def __repr__(self):
 204         return '<%s.%s for "%s" at 0x%x>' % (self.__class__.__module__,
 205                                              self.__class__.__name__,
 206                                              self.dir,
 207                                              id(self))
 208
 209
 210 ######################################################################
 211 #
 212 # Emulate the standard path-style import mechanism
 213 #
 214 class PathImporter(imputil.Importer):
 215     def __init__(self, path=sys.path):
 216         self.path = path
 217
 218     def get_code(self, parent, modname, fqname):
 219         if parent:
 220             # we are looking for a module inside of a specific package
 221             return _fs_import(parent.__pkgdir__, modname, fqname)
 222
 223         # scan sys.path, looking for the requested module
 224         for dir in self.path:
 225             if isinstance(dir, _StringType):
 226                 result = _fs_import(dir, modname, fqname)
 227                 if result:
 228                     return result
 229
 230         # not found
 231         return None
 232
 233 ######################################################################
 234
 235 def _test_dir():
 236     "Debug/test function to create DirectoryImporters from sys.path."
 237     imputil.ImportManager().install()
 238     path = sys.path[:]
 239     path.reverse()
 240     for d in path:
 241         sys.path.insert(0, DirectoryImporter(d))
 242     sys.path.insert(0, imputil.BuiltinImporter())
 243
 244 def _test_revamp():
 245     "Debug/test function for the revamped import system."
 246     imputil.ImportManager().install()
 247     sys.path.insert(0, PathImporter())
 248     sys.path.insert(0, imputil.BuiltinImporter())