Removing this file again to set its status to 'dead'.

1 files changed, 0 insertions, 1570 deletions

diff --git a/Lib/newimp.py b/Lib/newimp.py
deleted file mode 100755
index 231a33d..0000000
--- a/Lib/newimp.py
+++ /dev/null
@@ -1,1570 +0,0 @@
-"""Prototype of 'import' functionality enhanced to implement packages.
-
-Why packages?  Packages enable module nesting and sibling module
-imports.  'Til now, the python module namespace was flat, which
-means every module had to have a unique name, in order to not
-conflict with names of other modules on the load path.  Furthermore,
-suites of modules could not be structurally affiliated with one
-another.
-
-With packages, a suite of, eg, email-oriented modules can include a
-module named 'mailbox', without conflicting with the, eg, 'mailbox'
-module of a shared-memory suite - 'email.mailbox' vs
-'shmem.mailbox'.  Packages also enable modules within a suite to
-load other modules within their package without having the package
-name hard-coded.  Similarly, package suites of modules can be loaded
-as a unit, by loading the package that contains them.
-
-Usage: once installed (newimp.install(); newimp.revert() to revert to
-the prior __import__ routine), 'import ...' and 'from ... import ...'
-can be used to:
-
-  - import modules from the search path, as before.
-
-  - import modules from within other directory "packages" on the search
-    path using a '.' dot-delimited nesting syntax.  The nesting is fully
-    recursive.
-
-    For example, 'import test.test_types' will import the test_types
-    module within the 'test' package.  The calling environment would
-    then access the module as 'test.test_types', which is the name of
-    the fully-loaded 'test_types' module.  It is found contained within
-    the stub (ie, only partially loaded) 'test' module, hence accessed as
-    'test.test_types'.
-
-  - import siblings from modules within a package, using '__.' as a shorthand
-    prefix to refer to the parent package.  This enables referential
-    transparency - package modules need not know their package name.
-
-    The '__' package references are actually names assigned within
-    modules, to refer to their containing package.  This means that
-    variable references can be made to imported modules, or to variables
-    defined via 'import ... from', also using the '__.var' shorthand
-    notation.  This establishes a proper equivalence between the import
-    reference '__.sibling' and the var reference '__.sibling'.  
-
-  - import an entire package as a unit, by importing the package directory.
-    If there is a module named '__init__.py' in the package, it controls the
-    load.  Otherwise, all the modules in the dir, including packages, are
-    inherently loaded into the package module's namespace.
-
-    For example, 'import test' will load the modules of the entire 'test'
-    package, at least until a test failure is encountered.
-
-    In a package, a module with the name '__init__' has a special role.
-    If present in a package directory, then it is loaded into the package
-    module, instead of loading the contents of the directory.  This
-    enables the __init__ module to control the load, possibly loading
-    the entire directory deliberately (using 'import __', or even
-    'from __ import *', to load all the module contents directly into the
-    package module).
-
-  - perform any combination of the above - have a package that contains
-    packages, etc.
-
-Modules have a few new attributes in support of packages.  As mentioned
-above, '__' is a shorthand attribute denoting the modules' parent package,
-also denoted in the module by '__package__'.  Additionally, modules have
-associated with them a '__pkgpath__', a path by which sibling modules are
-found."""
-
-__version__ = "$Revision$"
-
-# $Id$ First release:
-# Ken.Manheimer@nist.gov, 5-Apr-1995, for python 1.2
-
-# Issues (scattered in code - search for three asterisks)
-# *** Despite my efforts, 'reload(newimp)' will foul things up.
-# *** Normalize_pathname will only work for Unix - which we need to detect.
-# *** when a module with the name of the platform (as indicated by
-#     to-be-created var sys.platform), the package path gets '.' and the
-#     platform dir.
-# *** use sys.impadmin for things like an import load-hooks var
-# *** Import-load-hook keying module name versus package path, which dictates
-#     additions to the default ('.' and os-specific dir) path
-# *** Document that the __init__.py can set __.__pkgpath__, in which case that
-#     will be used for the package-relative loads.
-# *** Add a 'recursive' option to reload, for reload of package constituent
-#     modules (including subpackages), as well.  Or maybe that should be the
-#     default, and eg stub-completion should override that default.  ???
-
-# Developers Notes:
-#
-# - 'sys.stub_modules' registers "incidental" (partially loaded) modules.
-#   A stub module is promoted to the fully-loaded 'sys.modules' list when it is
-#   explicitly loaded as a unit.
-# - One load nuance - the actual load of most module types goes into the
-#   already-generated stub module.  HOWEVER, eg dynamically loaded modules
-#   generate a new module object, which must supplant the existing stub.  One
-#   consequence is that the import process must use indirection through
-#   sys.stub_modules or sys.modules to track the actual modules across some of
-#   the phases.
-# - The test routines are cool, including a transient directory
-#   hierarchy facility, and a means of skipping to later tests by giving
-#   the test routine a numeric arg.
-# - There may still be some loose ends, not to mention bugs.  But the full
-#   functionality should be there.
-# - The ImportStack object is necessary to carry the list of in-process imports
-#   across very open-ended recursions, where the state cannot be passed
-#   explicitly via the import_module calls; for a primary example, via exec of
-#   an 'import' statement within a module.
-# - Python's (current) handling of extension modules, via imp.load_dynamic,
-#   does too much, some of which needs to be undone.  See comments in
-#   load_module.  Among other things, we actually change the __name__ of the
-#   module, which conceivably may break something.
-
-try:
-    VERBOSE
-except NameError:
-    VERBOSE = 0				# Will be reset by init(1), also.
-
-import sys, string, regex, types, os, marshal, traceback
-import __main__, __builtin__
-
-newimp_globals = vars()
-
-try:
-    import imp				# Build on this recent addition
-except ImportError:
-    raise ImportError, 'Pkg import module depends on optional "imp" module'#==X
-
-from imp import SEARCH_ERROR, PY_SOURCE, PY_COMPILED, C_EXTENSION
-
-def defvar(varNm, envDict, val, override=0):
-    """If VARNAME does not have value in DICT, assign VAL to it.  Optional arg
-    OVERRIDE means force the assignment in any case."""
-    if (not envDict.has_key(varNm)) or override:
-	envDict[varNm] = val
-    
-def init(full_reset=0):
-    """Do environment initialization, including retrofitting sys.modules with
-    module attributes."""
-    # Retrofit all existing modules with package attributes, under auspices of
-    # __root__:
-
-    locals, globals = vars(), newimp_globals
-
-    if full_reset:
-	global VERBOSE
-	VERBOSE = 0
-
-    # sys.stub_modules tracks modules partially loaded modules, ie loaded only
-    # incidental to load of nested components.  Together with sys.modules and
-    # the import stack, it serves as part of the module registration mechanism.
-    defvar('stub_modules', sys.__dict__, {}, full_reset)
-
-    # Environment setup - "root" module, '__root__'
-    # Establish root package '__root__' in __main__ and newimp envs.
-
-    # Longhand for name of variable identifying module's containing package:
-    defvar('PKG_NM', globals, "__package__", full_reset)
-    # Shorthand for module's container:
-    defvar('PKG_SHORT_NM', globals, "__", full_reset)
-    defvar('PKG_SHORT_NM_LEN', globals, len(PKG_SHORT_NM), full_reset)
-
-    # Name of controlling module for a package, if any:
-    defvar('INIT_MOD_NM', globals, "__init__", full_reset)
-
-    # Paths eventually will be extended to accomodate non-filesystem media -
-    # eg, URLs, composite objects, who knows.
-
-    # Name assigned in sys for general import administration:
-    defvar('IMP_SYS_NM', globals, "imp_admin", full_reset)
-    defvar('MOD_LOAD_HOOKS', globals, "mod_load_hooks", full_reset)
-    if full_reset:
-	defvar(IMP_SYS_NM, sys.__dict__, {MOD_LOAD_HOOKS: {}}, full_reset)
-    
-
-    # Name assigned in each module to tuple describing module import attrs:
-    defvar('IMP_ADMIN', globals, "__impadmin__", full_reset)
-    # The load-path obtaining for this package.  Not defined for non-packages.
-    # If not set, package directory is used.  If no package directory
-    # registered, sys.path is used.
-    defvar('PKG_PATH', globals, 0, full_reset)
-    # File from which module was loaded - may be None, eg, for __root__:
-    defvar('MOD_TYPE', globals, 1, full_reset)
-    # Exact path from which the module was loaded:
-    defvar('MOD_PATHNAME', globals, 2, full_reset)
-    # Package within which the module was found:
-    defvar('MOD_PACKAGE', globals, 3, full_reset)
-    defvar('USE_PATH', globals, 'either PKG_PATH or my dir', full_reset)
-    
-    # We're aliasing the top-level __main__ module as '__root__':
-    defvar('__root__', globals, __main__, full_reset)
-    defvar('ROOT_MOD_NM', globals, "__root__", full_reset)
-    if not sys.modules.has_key('__root__') or full_reset:
-	# and register it as an imported module:
-	sys.modules[ROOT_MOD_NM] = __root__
-
-    # Register package information in all existing top-level modules - they'll
-    # the None's mean, among other things, that their USE_PATH's all defer to
-    # sys.path.
-    for aMod in sys.modules.values():
-	if (not aMod.__dict__.has_key(PKG_NM)) or full_reset:
-	    set_mod_attrs(aMod, None, __root__, None, None)
-
-    try:
-	__builtin__.__import__
-	defvar('origImportFunc', globals, __builtin__.__import__)
-	defvar('origReloadFunc', globals, __builtin__.reload)
-    except AttributeError:
-	pass
-
-    defvar('PY_PACKAGE', globals, 4, full_reset)
-    defvar('PY_FROZEN', globals, 5, full_reset)
-    defvar('PY_BUILTIN', globals, 6, full_reset)
-
-    # Establish lookup table from mod-type "constants" to names:
-    defvar('mod_types', globals,
-	   {SEARCH_ERROR: 'SEARCH_ERROR',
-	    PY_SOURCE: 'PY_SOURCE',
-	    PY_COMPILED: 'PY_COMPILED',
-	    C_EXTENSION: 'C_EXTENSION',
-	    PY_PACKAGE: 'PY_PACKAGE',
-	    PY_FROZEN: 'PY_FROZEN',
-	    PY_BUILTIN: 'PY_BUILTIN'},
-	   full_reset)
-
-    defvar('stack', globals, ImportStack(), full_reset)
-
-def install():
-    """Install newimp import_module() routine, for package support.
-
-    newimp.revert() reverts to __import__ routine that was superceded."""
-    __builtin__.__import__ = import_module
-    __builtin__.reload = reload
-    __builtin__.unload = unload
-    __builtin__.bypass = bypass
-    return 'Enhanced import functionality in place.'
-def revert():
-    """Revert to original __builtin__.__import__ func, if newimp.install() has
-    been executed."""
-    if not (origImportFunc and origReloadFunc):
-	raise SystemError, "Can't find original import and reload funcs." # ==X
-    __builtin__.__import__ = origImportFunc
-    __builtin__.reload = origReloadFunc
-    del __builtin__.unload, __builtin__.bypass
-    return 'Original import routines back in place.'
-
-def import_module(name,
-		  envLocals=None, envGlobals=None,
-		  froms=None,
-		  inPkg=None):
-    """Primary service routine implementing 'import' with package nesting.
-
-    NAME:		name as specified to 'import NAME' or 'from NAME...'
-    LOCALS, GLOBALS:	local and global dicts obtaining for import
-    FROMS:		list of strings of "..." in 'import blat from ...'
-    INPKG:		package to which the name search is restricted, for use
-    			by recursive package loads (from import_module()).
-
-    A subtle difference from the old import - modules that do fail
-    initialization will not be registered in sys.modules, ie will not, in
-    effect, be registered as being loaded.  Note further that packages which
-    fail their overall load, but have successfully loaded constituent modules,
-    will be accessible in the importing namespace as stub modules.
-
-    A new routine, 'newimp.bypass()', provides the means to circumvent
-    constituent modules that fail their load, in order to enable load of the
-    remainder of a package."""
-
-    rootMod = sys.modules[ROOT_MOD_NM]
-
-    note("import_module: seeking '%s'" % name, 1)
-
-    # We need callers environment dict for local path and resulting module
-    # binding.
-    if not envGlobals:
-	# This should not happen, but does for imports called from within
-	# functions.
-	envLocals, envGlobals = exterior()
-
-    if inPkg:
-	pkg = inPkg
-    elif envGlobals.has_key(PKG_NM):
-	pkg = envGlobals[PKG_NM]
-    else:
-	# ** KLUDGE - cover for modules that lack package attributes:
-	pkg = rootMod
-
-    if pkg != rootMod:
-	note(' - relative to package %s' % pkg)
-
-    modList = theMod = absNm = nesting = None
-
-    # Normalize
-    #  - absNm is absolute w.r.t. __root__
-    #  - relNm is relative w.r.t. pkg.
-    if inPkg:
-	absNm, relNm = pkg.__name__ + '.' + name, name
-    else:
-	absNm, relNm, pkg = normalize_import_ref(name, pkg)
-    note("Normalized: %s%s" % (absNm, (((relNm != absNm)
-					and (" ('%s' in %s)" % (relNm, pkg)))
-				       or '')), 3)
-
-    pkgPath = get_mod_attrs(pkg, USE_PATH)
-
-    try:			# try...finally guards import stack integrity.
-
-	if stack.push(absNm):
-	    # We're nested inside a containing import of this module, perhaps
-	    # indirectly.  Avoid infinite recursion at this point by using the
-	    # existing stub module, for now.  Load of it will be completed by
-	    # the superior import.
-	    note('recursion on in-process module %s, punting with stub' %
-		 absNm)
-	    theMod = stack.mod(absNm)
-
-	else:
-
-	    # Try to find already-imported:
-	    if sys.modules.has_key(absNm):
-		note('found ' + absNm + ' already imported')
-		theMod = sys.modules[absNm]
-		stack.mod(absNm, theMod)
-
-	    else:		# Actually do load, of one sort or another:
-
-		# Seek builtin or frozen first:
-		theMod = imp.init_builtin(absNm)
-		if theMod:
-		    set_mod_attrs(theMod, None, pkg, None, PY_BUILTIN)
-		    stack.mod(absNm, theMod)
-		    note('found builtin ' + absNm)
-		else:
-		    theMod = imp.init_frozen(absNm)
-		    if theMod:
-			set_mod_attrs(theMod, None, pkg, None, PY_FROZEN)
-			stack.mod(absNm, theMod)
-			note('found frozen ' + absNm)
-
-		if not theMod:
-		    # Not already-loaded, in-process, builtin, or frozen -
-		    # we're seeking in the outside world (filesystem):
-
-		    if sys.stub_modules.has_key(absNm):
-
-			# A package for which we have a stub:
-			theMod = reload(sys.stub_modules[absNm], inPkg)
-
-		    else:
-
-			# Now we actually search the fs.
-
-			if type(pkgPath) == types.StringType:
-			    pkgPath = [pkgPath]
-
-			# Find a path leading to the module:
-			modList = find_module(relNm, pkgPath, absNm)
-			if not modList:
-			    raise ImportError, ("module '%s' not found" % #==X
-						absNm)
-
-			# We have a list of successively nested dirs leading
-			# to the module, register with import admin, as stubs:
-			nesting = register_mod_nesting(modList, pkg)
-
-			# Load from file if necessary and possible:
-			modNm, modf, path, ty = modList[-1]
-			note('found type %s - %s' % (mod_types[ty[2]], absNm))
-
-			# Establish the module object in question:
-			theMod = procure_module(absNm)
-			stack.mod(absNm, theMod)
-			
-			# Do the load:
-			theMod = load_module(theMod, ty[2], modf, inPkg)
-
-			commit_mod_containment(absNm)
-
-		    # Successful load - promote to fully-imported status:
-		    register_module(theMod, theMod.__name__)
-
-
-	# We have a loaded module (perhaps stub): situate specified components,
-	# and return appropriate thing.  According to guido:
-	#
-	# "Note that for "from spam.ham import bacon" your function should
-	#  return the object denoted by 'spam.ham', while for "import
-	#  spam.ham" it should return the object denoted by 'spam' -- the
-	#  STORE instructions following the import statement expect it this
-	#  way."
-	# *** The above rationale should probably be reexamined, since newimp
-	#     actually takes care of populating the caller's namespace.
-
-	if not froms:
-
-	    # Return the outermost container, possibly stub:
-	    if nesting:
-		return find_mod_registration(nesting[0][0])
-	    else:
-		return find_mod_registration(string.splitfields(absNm,'.')[0])
-	else:
-
-	    return theMod
-
-    finally:				# Decrement stack registration:
-	stack.pop(absNm)
-	    
-
-def reload(module, inPkg = None):
-    """Re-parse and re-initialize an already (or partially) imported MODULE.
-
-    The argument can be an already loaded module object or a string name of a
-    loaded module or a "stub" module that was partially loaded package module
-    incidental to the full load of a contained module.
-    
-    This is useful if you have edited the module source file using an external
-    editor and want to try out the new version without leaving the Python
-    interpreter.  The return value is the resulting module object.
-
-    Contrary to the old 'reload', the load is sought from the same location
-    where the module was originally found.  If you wish to do a fresh load from
-    a different module on the path, do an 'unload()' and then an import.
-
-    When a module is reloaded, its dictionary (containing the module's
-    global variables) is retained.  Redefinitions of names will
-    override the old definitions, so this is generally not a problem.
-    If the new version of a module does not define a name that was
-    defined by the old version, the old definition remains.  This
-    feature can be used to the module's advantage if it maintains a
-    global table or cache of objects -- with a `try' statement it can
-    test for the table's presence and skip its initialization if
-    desired.
-
-    It is legal though generally not very useful to reload built-in or
-    dynamically loaded modules, except for `sys', `__main__' and
-    `__builtin__'.  In certain cases, however, extension modules are
-    not designed to be initialized more than once, and may fail in
-    arbitrary ways when reloaded.
-
-    If a module imports objects from another module using `from' ...
-    `import' ..., calling `reload()' for the other module does not
-    redefine the objects imported from it -- one way around this is to
-    re-execute the `from' statement, another is to use `import' and
-    qualified names (MODULE.NAME) instead.
-
-    If a module instantiates instances of a class, reloading the module
-    that defines the class does not affect the method definitions of
-    the instances, unless they are reinstantiated -- they continue to use the
-    old class definition.  The same is true for derived classes."""
-
-    if type(module) == types.StringType:
-	theMod = find_mod_registration(module)
-    elif type(module) == types.ModuleType:
-	theMod = module
-    else:
-	raise ImportError, '%s not already imported'			# ==X
-
-    if theMod in [sys.modules[ROOT_MOD_NM], sys.modules['__builtin__']]:
-	raise ImportError, 'cannot re-init internal module'		# ==X
-
-    try:
-	thePath = get_mod_attrs(theMod, MOD_PATHNAME)
-    except KeyError:
-	thePath = None
-
-    if not thePath:
-	# If we have no path for the module, we can only reload it from
-	# scratch:
-	note('no pathname registered for %s, doing full reload' % theMod)
-	unload(theMod)
-	envGlobals, envLocals = exterior()
-	return import_module(theMod.__name__,
-			     envGlobals, envLocals, None, inPkg)
-    else:
-
-	stack.mod(theMod.__name__, theMod)
-	ty = get_mod_attrs(theMod, MOD_TYPE)
-	if ty in [PY_SOURCE, PY_COMPILED]:
-	    note('reload invoked for %s %s' % (mod_types[ty], theMod))
-	    thePath, ty, openFile = prefer_compiled(thePath, ty)
-	else:
-	    openFile = open(thePath, get_suffixes(ty)[1])
-	return load_module(theMod,					# ==>
-			   ty,
-			   openFile,
-			   inPkg)
-def unload(module):
-    """Remove registration for a module, so import will do a fresh load.
-
-    Returns the module registries (sys.modules and/or sys.stub_modules) where
-    it was found."""
-    if type(module) == types.ModuleType:
-	module = module.__name__
-    gotit = []
-    for which in ['sys.modules', 'sys.stub_modules']:
-	m = eval(which)
-	try:
-	    del m[module]
-	    gotit.append(which)
-	except KeyError:
-	    pass
-    if not gotit:
-	raise ValueError, '%s not a module or a stub' % module		# ==X
-    else: return gotit
-def bypass(modNm):
-    """Register MODULE-NAME so module will be skipped, eg in package load."""
-    if sys.modules.has_key(modNm):
-	raise ImportError("'%s' already imported, cannot be bypassed." % modNm)
-    else:
-	sys.modules[modNm] = imp.new_module('bypass()ed module %s' % modNm)
-	commit_mod_containment(modNm)
-	
-
-def normalize_import_ref(name, pkg):
-    """Produce absolute and relative nm and relative pkg given MODNM and origin
-    PACKAGE, reducing out all '__'s in the process."""
-
-    # First reduce out all the '__' container-refs we can:
-    outwards, inwards = 0, []
-    for nm in string.splitfields(name, '.'):
-	if nm == PKG_SHORT_NM:
-	    if inwards:
-		# Pop a containing inwards:
-		del inwards[-1]
-	    else:
-		# (Effectively) leading '__' - notch outwards:
-		outwards = outwards + 1
-	else:
-	    inwards.append(nm)
-    inwards = string.joinfields(inwards, '.')
-
-    # Now identify the components:
-
-    if not outwards:
-	pkg = sys.modules[ROOT_MOD_NM]
-    else:
-	while outwards > 1:
-	    pkg = pkg.__dict__[PKG_NM]	# We'll just loop at top
-	    if pkg == __root__:
-		break							# ==v
-	    outwards = outwards - 1
-
-    if not inwards:			# Entire package:
-	return pkg.__name__, pkg.__name__, pkg				# ==>
-    else:				# Name relative to package:
-	if pkg == __root__:
-	    return inwards, inwards, pkg				# ==>
-	else:
-	    return pkg.__name__ + '.' + inwards, inwards, pkg		# ==>
-
-class ImportStack:
-    """Provide judicious support for mutually recursive import loops.
-
-    Mutually recursive imports, eg a module that imports the package that
-    contains it, which in turn imports the module, are not uncommon, and must
-    be supported judiciously.  This class is used to track cycles, so a module
-    already in the process of being imported (via 'stack.push(module)', and
-    concluded via 'stack.release(module)') is not redundantly pursued; *except*
-    when a module master '__init__.py' loads the module, in which case it is
-    'stack.relax(module)'ed, so the full import is pursued."""
-
-    def __init__(self):
-	self._cycles = {}
-	self._mods = {}
-	self._looped = []
-    def in_process(self, modNm):
-	"""1 if modNm load already in process, 0 otherwise."""
-	return self._cycles.has_key(modNm)				# ==>
-    def looped(self, modNm):
-	"""1 if modNm load has looped once or more, 0 otherwise."""
-	return modNm in self._looped
-    def push(self, modNm):
-	"""1 if modNm already in process and not 'relax'ed, 0 otherwise.
-	(Note that the 'looped' status remains even when the cycle count
-	returns to 1.  This is so error messages can indicate that it was, at
-	some point, looped during the import process.)"""
-	if self.in_process(modNm):
-	    self._looped.append(modNm)
-	    self._cycles[modNm] = self._cycles[modNm] + 1
-	    return 1							# ==>
-	else:
-	    self._cycles[modNm] = 1
-	    return 0							# ==>
-    def mod(self, modNm, mod=None):
-	"""Associate MOD-NAME with MODULE, for easy reference."""
-	if mod:
-	    self._mods[modNm] = mod
-	else:
-	    try:
-		return self._mods[modNm]				# ==>
-	    except KeyError:
-		return None
-    def pop(self, modNm):
-	"""Decrement stack count of MODNM"""
-	if self.in_process(modNm):
-	    amt = self._cycles[modNm] = self._cycles[modNm] - 1
-	    if amt < 1:
-		del self._cycles[modNm]
-		if modNm in self._looped:
-		    self._looped.remove(modNm)
-		if self._mods.has_key(modNm):
-		    del self._mods[modNm]
-    def relax(self, modNm):
-	"""Enable modNm load despite being registered as already in-process."""
-	if self._cycles.has_key(modNm):
-	    del self._cycles[modNm]
-
-def find_module(name, path, absNm=''):
-    """Locate module NAME on PATH.  PATH is pathname string or a list of them.
-
-    Note that up-to-date compiled versions of a module are preferred to plain
-    source, and compilation is automatically performed when necessary and
-    possible.
-
-    Returns a list of the tuples returned by 'find_mod_file()', one for
-    each nested level, deepest last."""
-
-    checked = []			# For avoiding redundant dir lists.
-
-    if not absNm: absNm = name
-
-    # Parse name into list of nested components, 
-    expNm = string.splitfields(name, '.')
-
-    for curPath in path:
-
-	if (type(curPath) != types.StringType) or (curPath in checked):
-	    # Disregard bogus or already investigated path elements:
-	    continue							# ==^
-	else:
-	    # Register it for subsequent disregard.
-	    checked.append(curPath)
-
-	if len(expNm) == 1:
-
-	    # Non-nested module name:
-
-	    got = find_mod_file(curPath, absNm)
-	    if got:
-		note('using %s' % got[2], 3)
-		return [got]						# ==>
-
-	else:
-
-	    # Composite name specifying nested module:
-
-	    gotList = []; nameAccume = expNm[0]
-
-	    got = find_mod_file(curPath, nameAccume)
-	    if not got:			# Continue to next prospective path.
-		continue						# ==^
-	    else:
-		gotList.append(got)
-		nm, file, fullPath, ty = got
-
-	    # Work on successively nested components:
-	    for component in expNm[1:]:
-		# 'ty'pe of containing component must be package:
-		if ty[2] != PY_PACKAGE:
-		    gotList, got = [], None
-		    break						# ==v
-		if nameAccume:
-		    nameAccume = nameAccume + '.' + component
-		else:
-		    nameAccume = component
-		got = find_mod_file(fullPath, nameAccume)
-		if got:
-		    gotList.append(got)
-		    nm, file, fullPath, ty = got
-		else:
-		    # Clear state vars:
-		    gotList, got, nameAccume = [], None, ''
-		    break						# ==v
-	    # Found nesting all the way to the specified tip:
-	    if got:
-		return gotList						# ==>
-
-    # Failed.
-    return None
-
-def find_mod_file(pathNm, modname):
-    """Find right module file given DIR and module NAME, compiling if needed.
-
-    If successful, returns quadruple consisting of:
-     - mod name,
-     - file object,
-     - full pathname for the found file,
-     - a description triple as contained in the list returned by get_suffixes.
-
-    Otherwise, returns None.
-
-    Note that up-to-date compiled versions of a module are preferred to plain
-    source, and compilation is automatically performed, when necessary and
-    possible."""
-
-    relNm = modname[1 + string.rfind(modname, '.'):]
-
-    for suff, mode, ty in get_suffixes():
-	fullPath = os.path.join(pathNm, relNm + suff)
-	note('trying ' + fullPath + '...', 4)
-	try:
-	    modf = open(fullPath, mode)
-	except IOError:
-	    # ** ?? Skip unreadable ones:
-	    continue							# ==^
-
-	if ty == PY_PACKAGE:
-	    # Enforce directory characteristic:
-	    if not os.path.isdir(fullPath):
-		note('Skipping non-dir match ' + fullPath, 3)
-		continue						# ==^
-	    else:
-		return (modname, modf, fullPath, (suff, mode, ty))	# ==>
-	    
-
-	elif ty in [PY_SOURCE, PY_COMPILED]:
-	    usePath, useTy, openFile = prefer_compiled(fullPath, ty)
-	    return (modname,						# ==>
-		    openFile,
-		    usePath,
-		    get_suffixes(useTy))
-
-	elif ty == C_EXTENSION:
-	    note('found C_EXTENSION ' + fullPath, 3)
-	    return (modname, modf, fullPath, (suff, mode, ty))		# ==>
-
-	else:
-	    raise SystemError, 'Unanticipated module type encountered'	# ==X
-
-    return None
-
-def prefer_compiled(path, ty, modf=None):
-    """Given a path to a .py or .pyc file, attempt to return a path to a
-    current pyc file, compiling the .py in the process if necessary.  Returns
-    the path to the most current version we can get."""
-
-    if ty == PY_SOURCE:
-	if not modf:
-	    try:
-		modf = open(path, 'r')
-	    except IOError:
-		pass
-	note('working from PY_SOURCE', 3)
-	# Try for a compiled version:
-	pyc = path + 'c'	# Sadly, we're presuming '.py' suff.
-	if (not os.path.exists(pyc) or
-	    (os.stat(path)[8] > os.stat(pyc)[8])):
-	    # Try to compile:
-	    pyc = compile_source(path, modf)
-	if pyc and not (os.stat(path)[8] > os.stat(pyc)[8]):
-	    # Either pyc was already newer or we just made it so; in either
-	    # case it's what we crave:
-	    note('but got newer compiled, ' + pyc, 3)
-	    try:
-		return (pyc, PY_COMPILED, open(pyc, 'rb'))		# ==>
-	    except IOError:
-		if modf:
-		    return (path, PY_SOURCE, modf)			# ==>
-		else:
-		    raise ImportError, 'Failed acces to .py and .pyc'	# ==X
-	else:
-	    note("couldn't get newer compiled, using PY_SOURCE", 3)
-	    if modf:
-		return (path, PY_SOURCE, modf)				# ==>
-	    else:
-		raise ImportError, 'Failed acces to .py and .pyc'	# ==X
-
-    elif ty == PY_COMPILED:
-	note('working from PY_COMPILED', 3)
-	if not modf:
-	    try:
-		modf = open(path, 'rb')
-	    except IOError:
-		return prefer_compiled(path[:-1], PY_SOURCE)
-	# Make sure it is current, trying to compile if necessary, and
-	# prefer source failing that:
-	note('found compiled ' + path, 3)
-	py = path[:-1]			# ** Presuming '.pyc' suffix
-	if not os.path.exists(py):
-	    note('pyc SANS py: ' + path, 3)
-	    return (path, PY_COMPILED, open(py, 'r'))			# ==>
-	elif (os.stat(py)[8] > os.stat(path)[8]):
-	    note('Forced to compile: ' + py, 3)
-	    pyc = compile_source(py, open(py, 'r'))
-	    if pyc:
-		return (pyc, PY_COMPILED, modf)				# ==>
-	    else:
-		note('failed compile - must use more recent .py', 3)
-		return (py, PY_SOURCE, open(py, 'r'))			# ==>
-	else:
-	    return (path, PY_COMPILED, modf)				# ==>
-
-def load_module(theMod, ty, theFile, fromMod):
-    """Load module NAME, of TYPE, from FILE, within MODULE.
-
-    Optional arg fromMod indicates the module from which the load is being done
-    - necessary for detecting import of __ from a package's __init__ module.
-
-    Return the populated module object."""
-
-    # Note: we mint and register intermediate package directories, as necessary
-    
-    name = theMod.__name__
-    nameTail = name[1 + string.rfind(name, '.'):]
-    thePath = theFile.name
-
-    if ty == PY_SOURCE:
-	exec_into(theFile, theMod, theFile.name)
-
-    elif ty == PY_COMPILED:
-	pyc = open(theFile.name, 'rb').read()
-	if pyc[0:4] != imp.get_magic():
-	    raise ImportError, 'bad magic number: ' + theFile.name	# ==X
-	code = marshal.loads(pyc[8:])
-	exec_into(code, theMod, theFile.name)
-
-    elif ty == C_EXTENSION:
-	# Dynamically loaded C_EXTENSION modules do too much import admin,
-	# themselves, which we need to *undo* in order to integrate them with
-	# the new import scheme.
-	# 1 They register themselves in sys.modules, registering themselves
-	#   under their top-level names.  Have to rectify that.
-	# 2 The produce their own module objects, *unless* they find an
-	#   existing module already registered a la 1, above.  We employ this
-	#   quirk to make it use the already generated module.
-	try:
-	    # Stash a ref to any module that is already registered under the
-	    # dyamic module's simple name (nameTail), so we can reestablish it
-	    # after the dynamic takes over its' slot:
-	    protMod = None
-	    if nameTail != name:
-		if sys.modules.has_key(nameTail):
-		    protMod = sys.modules[nameTail]
-	    # Trick the dynamic load, by registering the module we generated
-	    # under the nameTail of the module we're loading, so the one we're
-	    # loading will use that established module, rather than producing a
-	    # new one:
-	    sys.modules[nameTail] = theMod
-	    theMod = imp.load_dynamic(nameTail, thePath, theFile)
-	    theMod.__name__ = name
-	    # Cleanup dynamic mod's bogus self-registration, if necessary:
-	    if nameTail != name:
-		if protMod:
-		    # ... reinstating the one that was already there...
-		    sys.modules[nameTail] = protMod
-		else:
-		    if sys.modules.has_key(nameTail):
-			# Certain, as long os dynamics continue to misbehave.
-			del sys.modules[nameTail]
-	    stack.mod(name, theMod)
-	    if sys.stub_modules.has_key(name):
-		sys.stub_modules[name] = theMod
-	    elif sys.modules.has_key(name):
-		sys.modules[name] = theMod
-	except:
-	    # Provide import-nesting info, including signs of circularity:
-		raise sys.exc_type, import_trail_msg(str(sys.exc_value),# ==X
-						     sys.exc_traceback,
-						     name)
-    elif ty == PY_PACKAGE:
-	# Load package constituents, doing the controlling module *if* it
-	# exists *and* it isn't already in process:
-
-	init_mod_f = init_mod = None
-	if not stack.in_process(name + '.' + INIT_MOD_NM):
-	    # Not already doing __init__ - check for it:
-	    init_mod_f = find_mod_file(thePath, INIT_MOD_NM)
-	else:
-	    note('skipping already-in-process %s.%s' % (theMod.__name__,
-							INIT_MOD_NM))
-	got = {}
-	if init_mod_f:
-	    note("Found package's __init__: " + init_mod_f[2])
-	    # Enable full continuance of containing-package-load from __init__:
-	    if stack.in_process(theMod.__name__):
-		stack.relax(theMod.__name__)
-	    init_mod = import_module(INIT_MOD_NM,
-				     theMod.__dict__, theMod.__dict__,
-				     None,
-				     theMod)
-	else:
-	    # ... or else recursively load all constituent modules, except
-	    # __init__:
-	    for prospect in mod_prospects(thePath):
-		if prospect != INIT_MOD_NM:
-		    import_module(prospect,
-				  theMod.__dict__, theMod.__dict__,
-				  None,
-				  theMod)
-
-    else:
-	raise ImportError, 'Unimplemented import type: %s' % ty		# ==X
-
-    return theMod
-
-def exec_into(obj, module, path):
-    """Helper for load_module, execfile/exec path or code OBJ within MODULE."""
-
-    # This depends on ability of exec and execfile to mutilate, erhm, mutate
-    # the __dict__ of a module.  It will not work if/when this becomes
-    # disallowed, as it is for normal assignments.
-
-    try:
-	if type(obj) == types.FileType:
-	    execfile(path, module.__dict__, module.__dict__)
-	elif type(obj) in [types.CodeType, types.StringType]:
-	    exec obj in module.__dict__, module.__dict__
-    except:
-	    # Make the error message nicer?
-	    raise sys.exc_type, import_trail_msg(str(sys.exc_value),	# ==X
-						 sys.exc_traceback,
-						 module.__name__)
-	
-
-def mod_prospects(path):
-    """Return a list of prospective modules within directory PATH.
-
-    We actually return the distinct names resulting from stripping the dir
-    entries (excluding os.curdir and os.pardir) of their suffixes (as
-    represented by 'get_suffixes').
-
-    (Note that matches for the PY_PACKAGE type with null suffix are
-    implicitly constrained to be directories.)"""
-
-    # We actually strip the longest matching suffixes, so eg 'dbmmodule.so'
-    # mates with 'module.so' rather than '.so'.
-
-    dirList = os.listdir(path)
-    excludes = [os.curdir, os.pardir]
-    sortedSuffs = sorted_suffixes()
-    entries = []
-    for item in dirList:
-	if item in excludes: continue					# ==^
-	for suff in sortedSuffs:
-	    # *** ?? maybe platform-specific:
-	    sub = -1 * len(suff)
-	    if sub == 0:
-		if os.path.isdir(os.path.join(path, item)):
-		    entries.append(item)
-	    elif item[sub:] == suff:
-		it = item[:sub]
-		if not it in entries:
-		    entries.append(it)
-		break							# ==v
-    return entries
-		
-
-
-def procure_module(name):
-    """Return an established or else new module object having NAME.
-
-    First checks sys.modules, then sys.stub_modules."""
-
-    if sys.modules.has_key(name):
-	return sys.modules[name]					# ==>
-    elif sys.stub_modules.has_key(name):
-	return sys.stub_modules[name]					# ==>
-    else:
-	return (stack.mod(name) or imp.new_module(name))		# ==>
-
-def commit_mod_containment(name):
-    """Bind a module object and its containers within their respective
-    containers."""
-    cume, pkg = '', find_mod_registration(ROOT_MOD_NM)
-    for next in string.splitfields(name, '.'):
-	if cume:
-	    cume = cume + '.' + next
-	else:
-	    cume = next
-	cumeMod = find_mod_registration(cume)
-	pkg.__dict__[next] = cumeMod
-	pkg = cumeMod
-
-def register_mod_nesting(modList, pkg):
-    """Given find_module()-style NEST-LIST and parent PACKAGE, register new
-    package components as stub modules, and return list of nested
-    module/relative-name pairs.
-
-    Note that the modules objects are not situated in their containing packages
-    here - that is left 'til after a successful load, and done by
-    commit_mod_nesting()."""
-    nesting = []
-
-    for modNm, modF, path, ty in modList:
-
-	relNm = modNm[1 + string.rfind(modNm, '.'):]
-
-	if sys.modules.has_key(modNm):
-	    theMod = sys.modules[modNm]	# Nestle in containing package
-	    pkg = theMod		# Set as parent for next in sequence.
-	elif sys.stub_modules.has_key(modNm):
-	    # Similar to above...
-	    theMod = sys.stub_modules[modNm]
-	    pkg = theMod
-	else:
-	    theMod = procure_module(modNm)
-	    stack.mod(modNm, theMod)
-	    # *** ??? Should we be using 'path' instead of modF.name?  If not,
-	    # should we get rid of the 'path' return val?
-	    set_mod_attrs(theMod, normalize_pathname(modF.name),
-			  pkg, None, ty[2])
-	    if ty[2] == PY_PACKAGE:
-		# Register as a stub:
-		register_module(theMod, modNm, 1)
-	    pkg = theMod
-	nesting.append((theMod.__name__,relNm))
-
-    return nesting
-
-def register_module(theMod, name, stub=0):
-    """Properly register MODULE, NAME, and optional STUB qualification."""
-    
-    if stub:
-	sys.stub_modules[name] = theMod
-    else:
-	sys.modules[name] = theMod
-	if sys.stub_modules.has_key(name):
-	    del sys.stub_modules[name]
-
-def find_mod_registration(name):
-    """Find module named NAME sys.modules, .stub_modules, or on the stack."""
-    if sys.stub_modules.has_key(name):
-	return sys.stub_modules[name]					# ==>
-    elif sys.modules.has_key(name):
-	return sys.modules[name]					# ==>
-    else:
-	if stack.in_process(name):
-	    it = stack.mod(name)
-	    if it:
-		return it						# ==>
-	    else:
-		raise ValueError, '%s %s in %s or %s' % (name,		# ==X
-							 'not registered',
-							 'sys.modules',
-							 'sys.stub_modules')
-
-def get_mod_attrs(theMod, which = None):
-    """Get MODULE object's path, containing-package, and designated path.
-
-    Virtual attribute USE_PATH is derived from PKG_PATH, MOD_PATHNAME,
-    and/or sys.path, depending on the module type and settings."""
-    it = theMod.__dict__[IMP_ADMIN]
-    if which:
-	# Load path is either the explicitly designated load path for the
-	# package, or else the directory in which it resides:
-	if which == USE_PATH:
-	    if it[PKG_PATH]:
-		# Return explicitly designated path:
-		return it[PKG_PATH]					# ==>
-	    if it[MOD_PATHNAME]: 
-		if it[MOD_TYPE] == PY_PACKAGE:
-		    # Return the package's directory path:
-		    return [it[MOD_PATHNAME]]				# ==>
-		else:
-		    # Return the directory where the module resides:
-		    return [os.path.split(it[MOD_PATHNAME])[0]]		# ==>
-	    # No explicitly designated path - use sys.path, eg for system
-	    # modules, etc:
-	    return sys.path
-	return it[which]						# ==>
-    else:
-	return it							# ==>
-
-def set_mod_attrs(theMod, path, pkg, pkgPath, ty):
-    """Register MOD import attrs PATH, PKG container, and PKGPATH, linking
-    the package container into the module along the way."""
-    theDict = theMod.__dict__
-    try:
-	# Get existing one, if any:
-	it = theDict[IMP_ADMIN]
-    except KeyError:
-	# None existing, gen a new one:
-	it = [None] * 4
-    for fld, val in ((MOD_PATHNAME, path), (MOD_PACKAGE, pkg),
-		     (PKG_PATH, pkgPath), (MOD_TYPE, ty)):
-	if val:
-	    it[fld] = val
-
-    theDict[IMP_ADMIN] = it
-    if pkg:
-	theDict[PKG_NM] = theDict[PKG_SHORT_NM] = pkg
-    return it								# ==>
-
-def format_tb_msg(tb, recursive):
-    """This should be in traceback.py, and traceback.print_tb() should use it
-    and traceback.extract_tb(), instead of print_tb() and extract_tb() having
-    so much redundant code!"""
-    tb_lines, formed = traceback.extract_tb(tb), ''
-    for line in tb_lines:
-	f, lno, nm, ln = line
-	if f[-1 * (len(__name__) + 3):] == __name__ + '.py':
-	    # Skip newimp notices - agregious hack, justified only by the fact
-	    # that this functionality will be properly doable in new impending
-	    # exception mechanism:
-	    continue
-	formed = formed + ('\n%s File "%s", line %d, in %s%s' %
-			   (((recursive and '*') or ' '),
-			    f, lno, nm,
-			    ((ln and '\n    ' + string.strip(ln)) or '')))
-    return formed
-
-def import_trail_msg(msg, tb, modNm):
-    """Doctor an error message to include the path of the current import, and
-    a sign that it is a circular import, if so."""
-    return (msg +
-	    format_tb_msg(tb,
-			  (stack.looped(modNm) and stack.in_process(modNm))))
-
-def compile_source(sourcePath, sourceFile):
-    """Given python code source path and file obj, Create a compiled version.
-
-    Return path of compiled version, or None if file creation is not
-    successful.  (Compilation errors themselves are passed without restraint.)
-
-    This is an import-private interface, and not well-behaved for general use.
-    
-    In particular, we presume the validity of the sourcePath, and that it
-    includes a '.py' extension."""
-
-    compiledPath = sourcePath[:-3] + '.pyc'
-    try:
-	compiledFile = open(compiledPath, 'wb')
-    except IOError:
-	note("write permission denied to " + compiledPath, 3)
-	return None
-    mtime = os.stat(sourcePath)[8]
-
-    try:
-	compiled = compile(sourceFile.read(), sourcePath, 'exec')
-    except SyntaxError:
-	    # Doctor the exception a bit, to include the source file name in
-	    # the report, and then reraise the doctored version.
-	    os.unlink(compiledFile.name)
-	    sys.exc_value = ((sys.exc_value[0] + ' in ' + sourceFile.name,)
-			     + sys.exc_value[1:])
-	    raise sys.exc_type, sys.exc_value				# ==X
-
-    # Ok, we have a valid compilation.
-    try:
-	compiledFile.write(imp.get_magic())		# compiled magic number
-	compiledFile.seek(8, 0)				# mtime space holder
-	marshal.dump(compiled, compiledFile)		# write the code obj
-	compiledFile.seek(4, 0)				# position for mtime
-	compiledFile.write(marshal.dumps(mtime)[1:])	# register mtime
-	compiledFile.flush()
-	compiledFile.close()
-	return compiledPath
-    except IOError:
-	return None							# ==>
-
-
-got_suffixes = None
-got_suffixes_dict = {}
-def get_suffixes(ty=None):
-    """Produce a list of triples, each describing a type of import file.
-
-    Triples have the form '(SUFFIX, MODE, TYPE)', where:
-
-    SUFFIX is a string found appended to a module name to make a filename for
-    that type of import file.
-
-    MODE is the mode string to be passed to the built-in 'open' function - "r"
-    for text files, "rb" for binary.
-
-    TYPE is the file type:
-
-     PY_SOURCE:		python source code,
-     PY_COMPILED:	byte-compiled python source,
-     C_EXTENSION:	compiled-code object file,
-     PY_PACKAGE:	python library directory, or
-     SEARCH_ERROR:	no module found. """
-
-    # Note: sorted_suffixes() depends on this function's value being invariant.
-    # sorted_suffixes() must be revised if this becomes untrue.
-    
-    global got_suffixes, got_suffixes_dict
-
-    if not got_suffixes:
-	# Ensure that the .pyc suffix precedes the .py:
-	got_suffixes = [('', 'r', PY_PACKAGE)]
-	got_suffixes_dict[PY_PACKAGE] = ('', 'r', PY_PACKAGE)
-	py = pyc = None
-	for suff in imp.get_suffixes():
-	    got_suffixes_dict[suff[2]] = suff
-	    if suff[0] == '.py':
-		py = suff
-	    elif suff[0] == '.pyc':
-		pyc = suff
-	    else:
-		got_suffixes.append(suff)
-	got_suffixes.append(pyc)
-	got_suffixes.append(py)
-    if ty:
-	return got_suffixes_dict[ty]					# ==>
-    else:
-	return got_suffixes						# ==>
-		
-
-sortedSuffs = []			# State vars for sorted_suffixes().  Go
-def sorted_suffixes():
-    """Helper function ~efficiently~ tracks sorted list of module suffixes."""
-
-    # Produce sortedSuffs once - this presumes that get_suffixes does not
-    # change from call to call during a python session.  Needs to be
-    # corrected if that becomes no longer true.
-
-    global sortedsuffs
-    if not sortedSuffs:			# do compute only the "first" time
-	for item in get_suffixes():
-	    sortedSuffs.append(item[0])
-	# Sort them in descending order:
-	sortedSuffs.sort(lambda x, y: (((len(x) > len(y)) and 1) or
-				       ((len(x) < len(y)) and -1)))
-	sortedSuffs.reverse()
-    return sortedSuffs
-
-
-def normalize_pathname(path):
-    """Given PATHNAME, return an absolute pathname relative to cwd, reducing
-    unnecessary components where convenient (eg, on Unix)."""
-
-    # We do a lot more when we have posix-style paths, eg os.sep == '/'.
-
-    if os.sep != '/':
-	return os.path.join(os.getcwd, path)				# ==>
-
-    outwards, inwards = 0, []
-    for nm in string.splitfields(path, os.sep):
-	if nm != os.curdir:
-	    if nm == os.pardir:
-		# Translate parent-dir entries to outward notches:
-		if inwards:
-		    # Pop a containing inwards:
-		    del inwards[-1]
-		else:
-		    # Register leading outward notches:
-		    outwards = outwards + 1
-	    else:
-		inwards.append(nm)
-    inwards = string.joinfields(inwards, os.sep)
-
-    if (not inwards) or (inwards[0] != os.sep):
-	# Relative path - join with current working directory, (ascending
-	# outwards to account for leading parent-dir components):
-	cwd = os.getcwd()
-	if outwards:
-	    cwd = string.splitfields(cwd, os.sep)
-	    cwd = string.joinfields(cwd[:len(cwd) - outwards], os.sep)
-	if inwards:
-	    return os.path.join(cwd, inwards)				# ==>
-	else:
-	    return cwd							# ==>
-    else:
-	return inwards							# ==>
-
-
-# exterior(): Utility routine, obtain local and global dicts of environment
-#	      containing/outside the callers environment, ie that of the
-#	      caller's caller.  Routines can use exterior() to determine the
-#	      environment from which they were called. 
-
-def exterior():
-    """Return dyad containing locals and globals of caller's caller.
-
-    Locals will be None if same as globals, ie env is global env."""
-
-    bogus = 'bogus'			# A locally usable exception
-    try: raise bogus			# Force an exception object
-    except bogus:
-	at = sys.exc_traceback.tb_frame.f_back		# The external frame.
-	if at.f_back: at = at.f_back			# And further, if any.
-	globals, locals = at.f_globals, at.f_locals
-	if locals == globals:				# Exterior is global?
-	    locals = None
-	return (locals, globals)
-
-#########################################################################
-#			      TESTING FACILITIES			#
-
-def note(msg, threshold=2):
-    if VERBOSE >= threshold: sys.stderr.write('(import: ' + msg + ')\n')
-
-class TestDirHier:
-    """Populate a transient directory hierarchy according to a definition
-    template - so we can create package/module hierarchies with which to
-    exercise the new import facilities..."""
-
-    def __init__(self, template, where='/var/tmp'):
-	"""Establish a dir hierarchy, according to TEMPLATE, that will be
-	deleted upon deletion of this object (or deliberate invocation of the
-	__del__ method)."""
-	self.PKG_NM = 'tdh_'
-	rev = 0
-	while os.path.exists(os.path.join(where, self.PKG_NM+str(rev))):
-	    rev = rev + 1
-	sys.exc_traceback = None	# Ensure Discard of try/except obj ref
-	self.PKG_NM = self.PKG_NM + str(rev)
-	self.root = os.path.join(where, self.PKG_NM)
-	self.createDir(self.root)
-	self.add(template)
-
-    def __del__(self):
-	"""Cleanup the test hierarchy."""
-	self.remove()
-    def add(self, template, root=None):
-	"""Populate directory according to template dictionary.
-
-	Keys indicate file names, possibly directories themselves.
-
-	String values dictate contents of flat files.
-
-	Dictionary values dictate recursively embedded dictionary templates."""
-	if root == None: root = self.root
-	for key, val in template.items():
-	    name = os.path.join(root, key)
-	    if type(val) == types.StringType:	# flat file
-		self.createFile(name, val)
-	    elif type(val) == types.DictionaryType:	# embedded dir
-		self.createDir(name)
-		self.add(val, name)
-	    else:
-		raise ValueError, ('invalid file-value type, %s' %	# ==X
-				   type(val))
-    def remove(self, name=''):
-	"""Dispose of the NAME (or keys in dictionary), using 'rm -r'."""
-	name = os.path.join(self.root, name)
-	sys.exc_traceback = None	# Ensure Discard of try/except obj ref
-	if os.path.exists(name):
-	    print '(TestDirHier: eradicating %s)' % name
-	    os.system('rm -r ' + name)
-	else:
-	    raise IOError, "can't remove non-existent " + name		# ==X
-    def createFile(self, name, contents=None):
-	"""Establish file NAME with CONTENTS.
-
-	If no contents specfied, contents will be 'print NAME'."""
-	f = open(name, 'w')
-	if not contents:
-	    f.write("print '" + name + "'\n")
-	else:
-	    f.write(contents)
-	f.close
-    def createDir(self, name):
-	"""Create dir with NAME."""
-	return os.mkdir(name, 0755)
-
-skipToTest = 0
-atTest = 1
-def testExec(msg, execList, locals, globals):
-    global skipToTest, atTest
-    print 'Import Test:', '(' + str(atTest) + ')', msg, '...'
-    atTest = atTest + 1
-    if skipToTest > (atTest - 1):
-	print ' ... skipping til test', skipToTest
-	return
-    else:
-	print ''
-    for stmt in execList:
-	exec stmt in locals, globals
-
-def test(number=0, leaveHiers=0):
-    """Exercise import functionality, creating a transient dir hierarchy for
-    the purpose.
-
-    We actually install the new import functionality, temporarily, resuming the
-    existing function on cleanup."""
-
-    import __builtin__
-
-    global skipToTest, atTest
-    skipToTest = number
-    hier = None
-
-    def unloadFull(mod):
-	"""Unload module and offspring submodules, if any."""
-	modMod = ''
-	if type(mod) == types.StringType:
-	    modNm = mod
-	elif type(mod) == types.ModuleType:
-	    modNm = modMod.__name__
-	for subj in sys.modules.keys() + sys.stub_modules.keys():
-	    if subj[0:len(modNm)] == modNm:
-		unload(subj)
-
-    try:
-	__main__.testMods
-    except AttributeError:
-	__main__.testMods = []
-    testMods = __main__.testMods
-	
-
-    # Install the newimp routines, within a try/finally:
-    try:
-	sys.exc_traceback = None
-	wasImport = __builtin__.__import__	# Stash default
-	wasPath = sys.path
-    except AttributeError:
-	wasImport = None
-    try:
-	hiers = []; modules = []
-	global VERBOSE
-	wasVerbose, VERBOSE = VERBOSE, 1
-	__builtin__.__import__ = import_module	# Install new version
-
-	if testMods:		# Clear out imports from previous tests
-	    for m in testMods[:]:
-		unloadFull(m)
-		testMods.remove(m)
-
-	# ------
-	# Test 1
-	testExec("already imported module: %s" % sys.modules.keys()[0],
-		 ['import ' + sys.modules.keys()[0]],
-		 vars(), newimp_globals)
-	no_sirree = 'no_sirree_does_not_exist'
-	# ------
-	# Test 2
-	testExec("non-existent module: %s" % no_sirree,
-		 ['try: import ' + no_sirree +
-		  '\nexcept ImportError: pass'],
-		  vars(), newimp_globals)
-	got = None
-
-	# ------
-	# Test 3
-	# Find a module that's not yet loaded, from a list of prospects:
-	for mod in ['Complex', 'UserDict', 'UserList', 'calendar',
-		    'cmd', 'dis', 'mailbox', 'profile', 'random', 'rfc822']:
-	    if not (mod in sys.modules.keys()):
-		got = mod
-		break							# ==v
-	if got:
-	    testExec("not-yet loaded module: %s" % mod,
-		     ['import ' + mod, 'modules.append(got)'],
-		     vars(), newimp_globals)
-	else:
-	    testExec("not-yet loaded module: list exhausted, never mind",
-		     [], vars(), newimp_globals)
-
-	# Now some package stuff.
-
-	# ------
-	# Test 4
-	# First change the path to include our temp dir, copying so the
-	# addition can be revoked on cleanup in the finally, below:
-	sys.path = ['/var/tmp'] + sys.path[:]
-	# Now create a trivial package:
-	stmts = ["hier1 = TestDirHier({'a.py': 'print \"a.py executing\"'})",
-		 "hiers.append(hier1)",
-		 "base = hier1.PKG_NM",
-		 "exec 'import ' + base",
-		 "testMods.append(base)"]
-	testExec("trivial package, with one module, a.py",
-		 stmts, vars(), newimp_globals)
-
-	# ------
-	# Test 5
-	# Slightly less trivial package - reference to '__':
-	stmts = [("hier2 = TestDirHier({'ref.py': 'print \"Pkg __:\", __'})"),
-		 "base = hier2.PKG_NM",
-		 "hiers.append(hier2)",
-		 "exec 'import ' + base",
-		 "testMods.append(base)"]
-	testExec("trivial package, with module that has pkg shorthand ref",
-		 stmts, vars(), newimp_globals)
-
-	# ------
-	# Test 6
-	# Nested package, plus '__' references:
-
-	complexTemplate = {'ref.py': 'print "ref.py loading..."',
-			    'suite': {'s1.py': 'print "s1.py, in pkg:", __',
-				      'subsuite': {'sub1.py':
-						   'print "sub1.py"'}}}
-	stmts = [('print """%s\n%s\n%s\n%s\n%s\n%s"""' %
-		  ('.../',
-		   '    ref.py\t\t\t"ref.py loading..."',
-		   '    suite/',
-		   '	    s1.py \t\t"s1.py, in pkg: xxxx.suite"',
-		   '	    subsuite/',
-		   '		sub1.py		"sub1.py" ')),
-		 "hier3 = TestDirHier(complexTemplate)",
-		 "base = hier3.PKG_NM",
-		 "hiers.append(hier3)",
-		 "exec 'import ' + base",
-		 "testMods.append(base)"]
-	testExec("Significantly nestled package:",
-		 stmts, vars(), newimp_globals)
-
-	# ------
-	# Test 7
-	# Try an elaborate hierarchy which includes an __init__ master in one
-	# one portion, a ref across packages within the hierarchies, and an
-	# indirect recursive import which cannot be satisfied (and hence,
-	# prevents load of part of the hierarchy).
-	complexTemplate = {'mid':
-			   {'prime':
-			    {'__init__.py': 'import __.easy, __.nother',
-			     'easy.py': 'print "easy.py:", __name__',
-			     'nother.py': ('%s\n%s\n%s\n' %
-					   ('import __.easy',
-					    'print "nother got __.easy"',
-					    # __.__.awry should be found but
-					    # should not load successfully,
-					    # disrupting nother, but not easy
-					    'import __.__.awry'))},
-			    # continuing dict 'mid':
-			    'awry':
-			    {'__init__.py':
-			     ('%s\n%s' %
-			      ('print "got " + __name__',
-			       'from __ import *')),
-			     # This mutual recursion (b->a, a->d->b) should be
-			     # ok, since a.py sets ax before recursing.
-			     'a.py':	'ax = 1; from __.b import bx',
-			     'b.py':	'bx = 1; from __.a import ax'}}}
-	stmts = ["hier5 = TestDirHier(complexTemplate)",
-		 "base = hier5.PKG_NM",
-		 "testMods.append(base)",
-		 "hiers.append(hier5)",
-		 "exec 'import %s.mid.prime' % base",
-		 "print eval(base)",		# Verify the base was bound
-		 "testMods.append(base)"]
-	testExec("Elaborate, clean hierarchy",
-		 stmts, vars(), newimp_globals)
-
-	# ------
-	# test 8
-	# Here we disrupt the mutual recursion in the mid.awry package, so the
-	# import should now fail.
-	complexTemplate['mid']['awry']['a.py'] = 'from __.b import bx; ax = 1'
-	complexTemplate['mid']['awry']['b.py'] = 'from __.a import ax; bx = 1'
-	stmts = ["hier6 = TestDirHier(complexTemplate)",
-		 "base = hier6.PKG_NM",
-		 "testMods.append(base)",
-		 "hiers.append(hier6)",
-		 "work = ('import %s.mid.prime' % base)",
-		 ("try: exec work" +
-		  "\nexcept ImportError: print ' -- import failed, as ought'" +
-		  "\nelse: raise SystemError, sys.exc_value"),
-		 "testMods.append(base)"]
-	testExec("Elaborate hier w/ deliberately flawed import recursion",
-		 stmts, vars(), newimp_globals)
-
-	sys.exc_traceback = None	# Signify clean conclusion.
-
-    finally:
-	skipToTest = 0
-	atTest = 1
-	sys.path = wasPath
-	VERBOSE = wasVerbose
-	if wasImport:			# Resurrect prior routine
-	    __builtin__.__import__ = wasImport
-	else:
-	    del __builtin__.__import__
-	if leaveHiers:
-	    print 'Cleanup inhibited'
-	else:
-	    if sys.exc_traceback:
-		print ' ** Import test FAILURE... cleanup.'
-	    else:
-		print ' Import test SUCCESS... cleanup'
-	    for h in hiers: h.remove(); del h	# Dispose of test directories
-
-init()
-
-if __name__ == '__main__':
-    test()