class ImportHooksLookupTests(LookupsTestCase): """ Tests for lookup methods in the presence of L{ihooks}-style import hooks. Runs all of the tests from L{LookupsTestCase} after installing a custom import hook. """ if ModuleImporter == None: skip = "ihooks not available" def setUp(self): """ Perturb the normal import behavior subtly by installing an import hook. No custom behavior is provided, but this adds some extra frames to the call stack, which L{namedAny} must be able to account for. """ self.importer = ModuleImporter() self.importer.install() def tearDown(self): """ Uninstall the custom import hook. """ self.importer.uninstall()
class ImportHooksLookupTests(unittest.TestCase, LookupsTestCase): """ Tests for lookup methods in the presence of L{ihooks}-style import hooks. Runs all of the tests from L{LookupsTestCase} after installing a custom import hook. """ skip = ("ihooks support is broken, and has probably been broken since " "Python 2.6. On the other hand, no one should use ihooks.") def setUp(self): """ Perturb the normal import behavior subtly by installing an import hook. No custom behavior is provided, but this adds some extra frames to the call stack, which L{namedAny} must be able to account for. """ self.importer = ModuleImporter() self.importer.install() def tearDown(self): """ Uninstall the custom import hook. """ self.importer.uninstall()
def __init__(self, handlers={'xml': RedcodeRootHandler}): ModuleImporter.__init__(self) rh = RedcodeHooks(self.get_hooks()) if handlers==None: from redfootlib.server.redcode.handlers import RedcodeRootHandler handlers = {'xml': RedcodeRootHandler} rh.handlers = handlers self.set_hooks(rh)
def setUp(self): """ Perturb the normal import behavior subtly by installing an import hook. No custom behavior is provided, but this adds some extra frames to the call stack, which L{namedAny} must be able to account for. """ self.importer = ModuleImporter() self.importer.install()
def install(self): if not sys.modules.has_key(''): sys.modules[''] = package = imp.new_module('') package.__path__ = None self.loader.init_package(package) for m in sys.modules.values(): if not m: continue if not hasattr(m, '__'): self.loader.set_parent(m) ModuleImporter.install(self)
def import_module(self, name, globals={}, locals={}, fromlist=[]): module = ModuleImporter.import_module(self, name, globals, locals, fromlist) importing_module = globals.get('__name__', None) if importing_module: self.get_loader().add(module.__name__, importing_module) if fromlist: for mod_name in fromlist: self.get_loader().add("%s.%s" % (module.__name__, mod_name), importing_module) return module
def installImporter(): "This lets us import prep files directly" # the python import mechanics are only invoked if you call this, # since preppy has very few dependencies and I don't want to #add to them. from ihooks import ModuleLoader, ModuleImporter, install class PreppyLoader(ModuleLoader): "This allows prep files to be imported." def find_module_in_dir(self, name, dir, allow_packages=1): ModuleLoader = self.__class__.__bases__[0] stuff = ModuleLoader.find_module_in_dir(self, name, dir, allow_packages) if stuff: #print 'standard module loader worked' return stuff else: if dir: prepFileName = dir + os.sep + name + '.prep' else: prepFileName = name + '.prep' if os.path.isfile(prepFileName): #compile WITHOUT IMPORTING to avoid triggering recursion mod = compileModule(prepFileName, verbose=0, importModule=0) #now use the default... return ModuleLoader.find_module_in_dir( self, name, dir, allow_packages) else: return None loader = PreppyLoader() importer = ModuleImporter(loader=loader) install(importer)
def __init__(self, loader = None, verbose = 0): ModuleImporter.__init__(self, loader or PackageLoader(None, verbose), verbose)
"""New import scheme with package support.
def __init__(self, loader=None, verbose=0): ModuleImporter.__init__(self, loader or PackageLoader(None, verbose), verbose)
def __init__(self): ModuleImporter.__init__(self) self.set_loader(AutoReloadModuleLoader())
def __init__(self): hooks, verbose = (None, 1) loader = HTTPModuleLoader(hooks, verbose) ModuleImporter.__init__(self, loader, verbose)