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())