Vega strike Python Modules doc: ModuleImporter Class Reference

All Data Structures Namespaces Files Functions Variables

Inheritance diagram for ModuleImporter:

Public Member Functions
def	import_module

def	determine_parent

def	find_head_package

def	load_tail

def	ensure_fromlist

def	import_it

def	reload

Public Member Functions inherited from BasicModuleImporter
def	__init__

def	get_loader

def	set_loader

def	get_hooks

def	set_hooks

def	import_module

def	reload

def	unload

def	install

def	uninstall

Public Member Functions inherited from _Verbose
def	__init__

def	get_verbose

def	set_verbose

def	note

def	message

Additional Inherited Members
Data Fields inherited from BasicModuleImporter
	loader

	modules

	save_import_module

	save_reload

	save_unload

Detailed Description

A module importer that supports packages.

Definition at line 391 of file ihooks.py.

Member Function Documentation

def determine_parent	(	self,
		globals
	)

Definition at line 405 of file ihooks.py.

References BasicModuleImporter.modules.

 
     def determine_parent(self, globals):
         if not globals or not globals.has_key("__name__"):
             return None
         pname = globals['__name__']
         if globals.has_key("__path__"):
             parent = self.modules[pname]
             assert globals is parent.__dict__
             return parent
         if '.' in pname:
             i = pname.rfind('.')
             pname = pname[:i]
             parent = self.modules[pname]
             assert parent.__name__ == pname
             return parent
         return None

def ensure_fromlist	(	self,
		m,
		fromlist,
		recursive = `0`
	)

Definition at line 454 of file ihooks.py.

References ModuleImporter.ensure_fromlist(), and ModuleImporter.import_it().

 
     def ensure_fromlist(self, m, fromlist, recursive=0):
         for sub in fromlist:
             if sub == "*":
                 if not recursive:
                     try:
                         all = m.__all__
                     except AttributeError:
                         pass
                     else:
                         self.ensure_fromlist(m, all, 1)
                 continue
             if sub != "*" and not hasattr(m, sub):
                 subname = "%s.%s" % (m.__name__, sub)
                 submod = self.import_it(sub, subname, m)
                 if not submod:
                     raise ImportError, "No module named " + subname

def find_head_package	(	self,
		parent,
		name
	)

Definition at line 421 of file ihooks.py.

References ModuleImporter.import_it().

 
     def find_head_package(self, parent, name):
         if '.' in name:
             i = name.find('.')
             head = name[:i]
             tail = name[i+1:]
         else:
             head = name
             tail = ""
         if parent:
             qname = "%s.%s" % (parent.__name__, head)
         else:
             qname = head
         q = self.import_it(head, qname, parent)
         if q: return q, tail
         if parent:
             qname = head
             parent = None
             q = self.import_it(head, qname, parent)
             if q: return q, tail
         raise ImportError, "No module named " + qname

def import_it	(	self,
		partname,
		fqname,
		parent,
		force_load = `0`
	)

Definition at line 471 of file ihooks.py.

References BasicModuleImporter.modules.

 
     def import_it(self, partname, fqname, parent, force_load=0):
         if not partname:
             raise ValueError, "Empty module name"
         if not force_load:
             try:
                 return self.modules[fqname]
             except KeyError:
                 pass
         try:
             path = parent and parent.__path__
         except AttributeError:
             return None
         stuff = self.loader.find_module(partname, path)
         if not stuff:
             return None
         m = self.loader.load_module(fqname, stuff)
         if parent:
             setattr(parent, partname, m)
         return m

def import_module	(	self,
		name,
		globals = `None`,
		locals = `None`,
		fromlist = `None`
	)

Definition at line 395 of file ihooks.py.

References ModuleImporter.determine_parent(), ModuleImporter.ensure_fromlist(), ModuleImporter.find_head_package(), and ModuleImporter.load_tail().

 
     def import_module(self, name, globals=None, locals=None, fromlist=None):
         parent = self.determine_parent(globals)
         q, tail = self.find_head_package(parent, name)
         m = self.load_tail(q, tail)
         if not fromlist:
             return q
         if hasattr(m, "__path__"):
             self.ensure_fromlist(m, fromlist)
         return m

def load_tail	(	self,
		q,
		tail
	)

Definition at line 442 of file ihooks.py.

References ModuleImporter.import_it().

 
     def load_tail(self, q, tail):
         m = q
         while tail:
             i = tail.find('.')
             if i < 0: i = len(tail)
             head, tail = tail[:i], tail[i+1:]
             mname = "%s.%s" % (m.__name__, head)
             m = self.import_it(head, mname, m)
             if not m:
                 raise ImportError, "No module named " + mname
         return m

def reload	(	self,
		module
	)

Definition at line 491 of file ihooks.py.

References ModuleImporter.import_it(), and BasicModuleImporter.modules.

 
     def reload(self, module):
         name = module.__name__
         if '.' not in name:
             return self.import_it(name, name, None, force_load=1)
         i = name.rfind('.')
         pname = name[:i]
         parent = self.modules[pname]
         return self.import_it(name[i+1:], name, parent, force_load=1)
 

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation