demandimport: make it possible to disable by setting HGDEMANDIMPORT=disable

Convenient for debugging weird problems that are caused by demandimport or
obfuscated by it.

This is an undocumented developer feature.

mercurial/demandimport.py

@@ -1,174 +1,175 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)
 '''
 
-import __builtin__
+import __builtin__, os
 _origimport = __import__
 
 nothing = object()
 
 try:
     _origimport(__builtin__.__name__, {}, {}, None, -1)
 except TypeError: # no level argument
     def _import(name, globals, locals, fromlist, level):
         "call _origimport with no level argument"
         return _origimport(name, globals, locals, fromlist)
 else:
     _import = _origimport
 
 def _hgextimport(importfunc, name, globals, *args):
     try:
         return importfunc(name, globals, *args)
     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)
 
 class _demandmod(object):
     """module demand-loader and proxy"""
     def __init__(self, name, globals, locals, level=-1):
         if '.' in name:
             head, rest = name.split('.', 1)
             after = [rest]
         else:
             head = name
             after = []
         object.__setattr__(self, "_data",
                            (head, globals, locals, after, level))
         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, level = self._data
             mod = _hgextimport(_import, head, globals, locals, None, level)
             # 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__))
                 elif t:
                     subload(getattr(mod, h), t)
 
             for x in after:
                 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):
         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'):
             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, level=-1):
     if not locals 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:
         if level != -1:
             # from . import b,c,d or from .a import b,c,d
             return _origimport(name, globals, locals, fromlist, level)
         # from a import b,c,d
         mod = _hgextimport(_origimport, name, globals, locals)
         # recurse down the module chain
         for comp in name.split('.')[1:]:
             if getattr(mod, comp, nothing) is nothing:
                 setattr(mod, comp, _demandmod(comp, mod.__dict__, mod.__dict__))
             mod = getattr(mod, comp)
         for x in fromlist:
             # set requested submodules for demand load
             if getattr(mod, x, nothing) is nothing:
                 setattr(mod, x, _demandmod(x, mod.__dict__, locals))
         return mod
 
 ignore = [
     '_hashlib',
     '_xmlplus',
     'fcntl',
     'win32com.gen_py',
     '_winreg', # 2.7 mimetypes needs immediate ImportError
     'pythoncom',
     # imported by tarfile, not available under Windows
     'pwd',
     'grp',
     # imported by profile, itself imported by hotshot.stats,
     # not available under Windows
     'resource',
     # this trips up many extension authors
     'gtk',
     # setuptools' pkg_resources.py expects "from __main__ import x" to
     # raise ImportError if x not defined
     '__main__',
     '_ssl', # conditional imports in the stdlib, issue1964
     'rfc822',
     'mimetools',
     ]
 
 def isenabled():
     return __builtin__.__import__ == _demandimport
 
 def enable():
     "enable global demand-loading of modules"
-    __builtin__.__import__ = _demandimport
+    if os.environ.get('HGDEMANDIMPORT') != 'disable':
+        __builtin__.__import__ = _demandimport
 
 def disable():
     "disable global demand-loading of modules"
     __builtin__.__import__ = _origimport

tests/test-demandimport.py

@@ -1,39 +1,45 b''
 from mercurial import demandimport
 demandimport.enable()
 
 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)
 
 import re as fred
 print "fred =", f(fred)
 
 import sys as re
 print "re =", f(re)
 
 print "fred =", f(fred)
 print "fred.sub =", f(fred.sub)
 print "fred =", f(fred)
 
 print "re =", f(re)
 print "re.stderr =", f(re.stderr)
 print "re =", f(re)
+
+demandimport.disable()
+os.environ['HGDEMANDIMPORT'] = 'disable'
+demandimport.enable()
+from mercurial import node
+print "node =", f(node)

tests/test-demandimport.py.out

@@ -1,15 +1,16 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?>
 fred = <unloaded module 're'>
 re = <unloaded module 'sys'>
 fred = <unloaded module 're'>
 fred.sub = <function sub at 0x?>
 fred = <proxied module 're'>
 re = <unloaded module 'sys'>
 re.stderr = <open file '<whatever>', mode 'w' at 0x?>
 re = <proxied module 'sys'>
+node = <module 'mercurial.node' from '?'>