demandimport: fix import x.y.z as a when x.y is already imported.

mercurial/demandimport.py

@@ -1,109 +1,115
 # demandimport.py - global demand-loading of modules for Mercurial
 #
 # Copyright 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 '''
 demandimport - automatic demandloading of modules
 
 To enable this module, do:
 
   import demandimport; demandimport.enable()
 
 Imports of the following forms will be demand-loaded:
 
   import a, b.c
   import a.b as c
   from a import b,c # a will be loaded immediately
 
 These imports will not be delayed:
 
   from a import *
   b = __import__(a)
 '''
 
 _origimport = __import__
 
 class _demandmod(object):
     """module demand-loader and proxy"""
     def __init__(self, name, globals, locals):
         if '.' in name:
             head, rest = name.split('.', 1)
             after = [rest]
         else:
             head = name
             after = []
         object.__setattr__(self, "_data", (head, globals, locals, after))
         object.__setattr__(self, "_module", None)
     def _extend(self, name):
         """add to the list of submodules to load"""
         self._data[3].append(name)
     def _load(self):
         if not self._module:
             head, globals, locals, after = self._data
             mod = _origimport(head, globals, locals)
             # load submodules
+            def subload(mod, p):
+                h, t = p, None
+                if '.' in p:
+                    h, t = p.split('.', 1)
+                if not hasattr(mod, h):
+                    setattr(mod, h, _demandmod(p, mod.__dict__, mod.__dict__))
+                else:
+                    subload(getattr(mod, h), t)
+
             for x in after:
-                hx = x
-                if '.' in x:
-                    hx = x.split('.')[0]
-                if not hasattr(mod, hx):
-                    setattr(mod, hx, _demandmod(x, mod.__dict__, mod.__dict__))
+                subload(mod, x)
+
             # are we in the locals dictionary still?
             if locals and locals.get(head) == self:
                 locals[head] = mod
             object.__setattr__(self, "_module", mod)
     def __repr__(self):
         return "<unloaded module '%s'>" % self._data[0]
     def __call__(self, *args, **kwargs):
         raise TypeError("'unloaded module' object is not callable")
     def __getattribute__(self, attr):
         if attr in ('_data', '_extend', '_load', '_module'):
             return object.__getattribute__(self, attr)
         self._load()
         return getattr(self._module, attr)
     def __setattr__(self, attr, val):
         self._load()
         setattr(self._module, attr, val)
 
 def _demandimport(name, globals=None, locals=None, fromlist=None):
     if not locals or name in ignore or fromlist == ('*',):
         # these cases we can't really delay
         return _origimport(name, globals, locals, fromlist)
     elif not fromlist:
         # import a [as b]
         if '.' in name: # a.b
             base, rest = name.split('.', 1)
             # email.__init__ loading email.mime
             if globals and globals.get('__name__', None) == base:
                 return _origimport(name, globals, locals, fromlist)
             # if a is already demand-loaded, add b to its submodule list
             if base in locals:
                 if isinstance(locals[base], _demandmod):
                     locals[base]._extend(rest)
                 return locals[base]
         return _demandmod(name, globals, locals)
     else:
         # from a import b,c,d
         mod = _origimport(name, globals, locals)
         # recurse down the module chain
         for comp in name.split('.')[1:]:
             mod = getattr(mod, comp)
         for x in fromlist:
             # set requested submodules for demand load
             if not(hasattr(mod, x)):
                 setattr(mod, x, _demandmod(x, mod.__dict__, mod.__dict__))
         return mod
 
 ignore = []
 
 def enable():
     "enable global demand-loading of modules"
     __builtins__["__import__"] = _demandimport
 
 def disable():
     "disable global demand-loading of modules"
     __builtins__["__import__"] = _origimport