Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity
cpython/Lib/newimp.py

1571 lines
53 KiB
Python
Executable File
Raw Blame History

"""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()
Reference in New Issue View Git Blame Copy Permalink