demandimport: look for 'mod' suffix as alternative name for module reference

It's widely used in our codebase.

hgdemandimport/demandimportpy2.py

@@ -1,302 +1,305 b''
 # demandimport.py - global demand-loading of modules for Mercurial
 #
 # Copyright 2006, 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''
 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)
 '''
 
 from __future__ import absolute_import
 
 import contextlib
 import os
 import sys
 
 # __builtin__ in Python 2, builtins in Python 3.
 try:
     import __builtin__ as builtins
 except ImportError:
     import builtins
 
 contextmanager = contextlib.contextmanager
 
 _origimport = __import__
 
 nothing = object()
 
 # Python 3 doesn't have relative imports nor level -1.
 level = -1
 if sys.version_info[0] >= 3:
     level = 0
 _import = _origimport
 
 def _hgextimport(importfunc, name, globals, *args, **kwargs):
     try:
         return importfunc(name, globals, *args, **kwargs)
     except ImportError:
         if not globals:
             raise
         # extensions are loaded with "hgext_" prefix
         hgextname = 'hgext_%s' % name
         nameroot = hgextname.split('.', 1)[0]
         contextroot = globals.get('__name__', '').split('.', 1)[0]
         if nameroot != contextroot:
             raise
         # retry to import with "hgext_" prefix
         return importfunc(hgextname, globals, *args, **kwargs)
 
 class _demandmod(object):
     """module demand-loader and proxy
 
     Specify 1 as 'level' argument at construction, to import module
     relatively.
     """
 
     def __init__(self, name, globals, locals, level):
         if '.' in name:
             head, rest = name.split('.', 1)
             after = [rest]
         else:
             head = name
             after = []
         object.__setattr__(self, r"_data",
                            (head, globals, locals, after, level, set()))
         object.__setattr__(self, r"_module", None)
 
     def _extend(self, name):
         """add to the list of submodules to load"""
         self._data[3].append(name)
 
     def _addref(self, name):
         """Record that the named module ``name`` imports this module.
 
         References to this proxy class having the name of this module will be
         replaced at module load time. We assume the symbol inside the importing
         module is identical to the "head" name of this module. We don't
         actually know if "as X" syntax is being used to change the symbol name
         because this information isn't exposed to __import__.
         """
         self._data[5].add(name)
 
     def _load(self):
         if not self._module:
             head, globals, locals, after, level, modrefs = self._data
             mod = _hgextimport(_import, head, globals, locals, None, level)
             if mod is self:
                 # In this case, _hgextimport() above should imply
                 # _demandimport(). Otherwise, _hgextimport() never
                 # returns _demandmod. This isn't intentional behavior,
                 # in fact. (see also issue5304 for detail)
                 #
                 # If self._module is already bound at this point, self
                 # should be already _load()-ed while _hgextimport().
                 # Otherwise, there is no way to import actual module
                 # as expected, because (re-)invoking _hgextimport()
                 # should cause same result.
                 # This is reason why _load() returns without any more
                 # setup but assumes self to be already bound.
                 mod = self._module
                 assert mod and mod is not self, "%s, %s" % (self, mod)
                 return
 
             # load submodules
             def subload(mod, p):
                 h, t = p, None
                 if '.' in p:
                     h, t = p.split('.', 1)
                 if getattr(mod, h, nothing) is nothing:
                     setattr(mod, h, _demandmod(p, mod.__dict__, mod.__dict__,
                                                level=1))
                 elif t:
                     subload(getattr(mod, h), t)
 
             for x in after:
                 subload(mod, x)
 
             # Replace references to this proxy instance with the actual module.
-            if locals and locals.get(head) is self:
-                locals[head] = mod
+            if locals:
+                if locals.get(head) is self:
+                    locals[head] = mod
+                elif locals.get(head + r'mod') is self:
+                    locals[head + r'mod'] = mod
 
             for modname in modrefs:
                 modref = sys.modules.get(modname, None)
                 if modref and getattr(modref, head, None) is self:
                     setattr(modref, head, mod)
 
             object.__setattr__(self, r"_module", mod)
 
     def __repr__(self):
         if self._module:
             return "<proxied module '%s'>" % self._data[0]
         return "<unloaded module '%s'>" % self._data[0]
 
     def __call__(self, *args, **kwargs):
         raise TypeError("%s object is not callable" % repr(self))
 
     def __getattribute__(self, attr):
         if attr in ('_data', '_extend', '_load', '_module', '_addref'):
             return object.__getattribute__(self, attr)
         self._load()
         return getattr(self._module, attr)
 
     def __setattr__(self, attr, val):
         self._load()
         setattr(self._module, attr, val)
 
 _pypy = '__pypy__' in sys.builtin_module_names
 
 def _demandimport(name, globals=None, locals=None, fromlist=None, level=level):
     if locals is None or name in ignore or fromlist == ('*',):
         # these cases we can't really delay
         return _hgextimport(_import, name, globals, locals, fromlist, level)
     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 _import(name, globals, locals, fromlist, level)
             # 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, level)
     else:
         # There is a fromlist.
         # from a import b,c,d
         # from . import b,c,d
         # from .a import b,c,d
 
         # level == -1: relative and absolute attempted (Python 2 only).
         # level >= 0: absolute only (Python 2 w/ absolute_import and Python 3).
         # The modern Mercurial convention is to use absolute_import everywhere,
         # so modern Mercurial code will have level >= 0.
 
         # The name of the module the import statement is located in.
         globalname = globals.get('__name__')
 
         def processfromitem(mod, attr):
             """Process an imported symbol in the import statement.
 
             If the symbol doesn't exist in the parent module, and if the
             parent module is a package, it must be a module. We set missing
             modules up as _demandmod instances.
             """
             symbol = getattr(mod, attr, nothing)
             nonpkg = getattr(mod, '__path__', nothing) is nothing
             if symbol is nothing:
                 if nonpkg:
                     # do not try relative import, which would raise ValueError,
                     # and leave unknown attribute as the default __import__()
                     # would do. the missing attribute will be detected later
                     # while processing the import statement.
                     return
                 mn = '%s.%s' % (mod.__name__, attr)
                 if mn in ignore:
                     importfunc = _origimport
                 else:
                     importfunc = _demandmod
                 symbol = importfunc(attr, mod.__dict__, locals, level=1)
                 setattr(mod, attr, symbol)
 
             # Record the importing module references this symbol so we can
             # replace the symbol with the actual module instance at load
             # time.
             if globalname and isinstance(symbol, _demandmod):
                 symbol._addref(globalname)
 
         def chainmodules(rootmod, modname):
             # recurse down the module chain, and return the leaf module
             mod = rootmod
             for comp in modname.split('.')[1:]:
                 if getattr(mod, comp, nothing) is nothing:
                     setattr(mod, comp, _demandmod(comp, mod.__dict__,
                                                   mod.__dict__, level=1))
                 mod = getattr(mod, comp)
             return mod
 
         if level >= 0:
             if name:
                 # "from a import b" or "from .a import b" style
                 rootmod = _hgextimport(_origimport, name, globals, locals,
                                        level=level)
                 mod = chainmodules(rootmod, name)
             elif _pypy:
                 # PyPy's __import__ throws an exception if invoked
                 # with an empty name and no fromlist.  Recreate the
                 # desired behaviour by hand.
                 mn = globalname
                 mod = sys.modules[mn]
                 if getattr(mod, '__path__', nothing) is nothing:
                     mn = mn.rsplit('.', 1)[0]
                     mod = sys.modules[mn]
                 if level > 1:
                     mn = mn.rsplit('.', level - 1)[0]
                     mod = sys.modules[mn]
             else:
                 mod = _hgextimport(_origimport, name, globals, locals,
                                    level=level)
 
             for x in fromlist:
                 processfromitem(mod, x)
 
             return mod
 
         # But, we still need to support lazy loading of standard library and 3rd
         # party modules. So handle level == -1.
         mod = _hgextimport(_origimport, name, globals, locals)
         mod = chainmodules(mod, name)
 
         for x in fromlist:
             processfromitem(mod, x)
 
         return mod
 
 ignore = []
 
 def init(ignorelist):
     global ignore
     ignore = ignorelist
 
 def isenabled():
     return builtins.__import__ == _demandimport
 
 def enable():
     "enable global demand-loading of modules"
     if os.environ.get('HGDEMANDIMPORT') != 'disable':
         builtins.__import__ = _demandimport
 
 def disable():
     "disable global demand-loading of modules"
     builtins.__import__ = _origimport
 
 @contextmanager
 def deactivated():
     "context manager for disabling demandimport in 'with' blocks"
     demandenabled = isenabled()
     if demandenabled:
         disable()
 
     try:
         yield
     finally:
         if demandenabled:
             enable()

tests/test-demandimport.py

@@ -1,89 +1,95 b''
 from __future__ import print_function
 
 from mercurial import demandimport
 demandimport.enable()
 
 import os
 import subprocess
 import sys
 
 # Only run if demandimport is allowed
 if subprocess.call(['python', '%s/hghave' % os.environ['TESTDIR'],
                     'demandimport']):
     sys.exit(80)
 
 if os.name != 'nt':
     try:
         import distutils.msvc9compiler
         print('distutils.msvc9compiler needs to be an immediate '
               'importerror on non-windows platforms')
         distutils.msvc9compiler
     except ImportError:
         pass
 
 import re
 
 rsub = re.sub
 def f(obj):
     l = repr(obj)
     l = rsub("0x[0-9a-fA-F]+", "0x?", l)
     l = rsub("from '.*'", "from '?'", l)
     l = rsub("'<[a-z]*>'", "'<whatever>'", l)
     return l
 
 import os
 
 print("os =", f(os))
 print("os.system =", f(os.system))
 print("os =", f(os))
 
 from mercurial import util
 
 print("util =", f(util))
 print("util.system =", f(util.system))
 print("util =", f(util))
 print("util.system =", f(util.system))
 
 from mercurial import hgweb
 print("hgweb =", f(hgweb))
 print("hgweb_mod =", f(hgweb.hgweb_mod))
 print("hgweb =", f(hgweb))
 
 import re as fred
 print("fred =", f(fred))
 
+import re as remod
+print("remod =", f(remod))
+
 import sys as re
 print("re =", f(re))
 
 print("fred =", f(fred))
 print("fred.sub =", f(fred.sub))
 print("fred =", f(fred))
 
+remod.escape  # use remod
+print("remod =", f(remod))
+
 print("re =", f(re))
 print("re.stderr =", f(re.stderr))
 print("re =", f(re))
 
 import contextlib
 print("contextlib =", f(contextlib))
 try:
     from contextlib import unknownattr
     print('no demandmod should be created for attribute of non-package '
           'module:\ncontextlib.unknownattr =', f(unknownattr))
 except ImportError as inst:
     print('contextlib.unknownattr = ImportError: %s'
           % rsub(r"'", '', str(inst)))
 
 # Unlike the import statement, __import__() function should not raise
 # ImportError even if fromlist has an unknown item
 # (see Python/import.c:import_module_level() and ensure_fromlist())
 contextlibimp = __import__('contextlib', globals(), locals(), ['unknownattr'])
 print("__import__('contextlib', ..., ['unknownattr']) =", f(contextlibimp))
 print("hasattr(contextlibimp, 'unknownattr') =",
       util.safehasattr(contextlibimp, 'unknownattr'))
 
 demandimport.disable()
 os.environ['HGDEMANDIMPORT'] = 'disable'
 # this enable call should not actually enable demandimport!
 demandimport.enable()
 from mercurial import node
 print("node =", f(node))

tests/test-demandimport.py.out

@@ -1,23 +1,25 b''
 os = <unloaded module 'os'>
 os.system = <built-in function system>
 os = <module 'os' from '?'>
 util = <unloaded module 'util'>
 util.system = <function system at 0x?>
 util = <module 'mercurial.util' from '?'>
 util.system = <function system at 0x?>
 hgweb = <unloaded module 'hgweb'>
 hgweb_mod = <unloaded module 'hgweb_mod'>
 hgweb = <module 'mercurial.hgweb' from '?'>
 fred = <unloaded module 're'>
+remod = <unloaded module 're'>
 re = <unloaded module 'sys'>
 fred = <unloaded module 're'>
 fred.sub = <function sub at 0x?>
 fred = <proxied module 're'>
+remod = <module 're' from '?'>
 re = <unloaded module 'sys'>
 re.stderr = <open file '<whatever>', mode 'w' at 0x?>
 re = <proxied module 'sys'>
 contextlib = <unloaded module 'contextlib'>
 contextlib.unknownattr = ImportError: cannot import name unknownattr
 __import__('contextlib', ..., ['unknownattr']) = <module 'contextlib' from '?'>
 hasattr(contextlibimp, 'unknownattr') = False
 node = <module 'mercurial.node' from '?'>