Lines Matching refs:self
92 def __init__(self, name, file=None, path=None):
93 self.__name__ = name
94 self.__file__ = file
95 self.__path__ = path
96 self.__code__ = None
100 self.globalnames = {}
103 self.starimports = {}
105 def __repr__(self):
106 s = "Module(%r" % (self.__name__,)
107 if self.__file__ is not None:
108 s = s + ", %r" % (self.__file__,)
109 if self.__path__ is not None:
110 s = s + ", %r" % (self.__path__,)
116 def __init__(self, path=None, debug=0, excludes=None, replace_paths=None):
119 self.path = path
120 self.modules = {}
121 self.badmodules = {}
122 self.debug = debug
123 self.indent = 0
124 self.excludes = excludes if excludes is not None else []
125 self.replace_paths = replace_paths if replace_paths is not None else []
126 self.processed_paths = [] # Used in debugging only
128 def msg(self, level, str, *args):
129 if level <= self.debug:
130 for i in range(self.indent):
137 def msgin(self, *args):
139 if level <= self.debug:
140 self.indent = self.indent + 1
141 self.msg(*args)
143 def msgout(self, *args):
145 if level <= self.debug:
146 self.indent = self.indent - 1
147 self.msg(*args)
149 def run_script(self, pathname):
150 self.msg(2, "run_script", pathname)
153 self.load_module('__main__', fp, pathname, stuff)
155 def load_file(self, pathname):
160 self.load_module(name, fp, pathname, stuff)
162 def import_hook(self, name, caller=None, fromlist=None, level=-1):
163 self.msg(3, "import_hook", name, caller, fromlist, level)
164 parent = self.determine_parent(caller, level=level)
165 q, tail = self.find_head_package(parent, name)
166 m = self.load_tail(q, tail)
170 self.ensure_fromlist(m, fromlist)
173 def determine_parent(self, caller, level=-1):
174 self.msgin(4, "determine_parent", caller, level)
176 self.msgout(4, "determine_parent -> None")
183 parent = self.modules[pname]
185 self.msgout(4, "determine_parent ->", parent)
190 parent = self.modules[pname]
191 self.msgout(4, "determine_parent ->", parent)
194 parent = self.modules[pname]
196 self.msgout(4, "determine_parent ->", parent)
201 parent = self.modules[pname]
203 self.msgout(4, "determine_parent ->", parent)
205 self.msgout(4, "determine_parent -> None")
208 def find_head_package(self, parent, name):
209 self.msgin(4, "find_head_package", parent, name)
221 q = self.import_module(head, qname, parent)
223 self.msgout(4, "find_head_package ->", (q, tail))
228 q = self.import_module(head, qname, parent)
230 self.msgout(4, "find_head_package ->", (q, tail))
232 self.msgout(4, "raise ImportError: No module named", qname)
235 def load_tail(self, q, tail):
236 self.msgin(4, "load_tail", q, tail)
243 m = self.import_module(head, mname, m)
245 self.msgout(4, "raise ImportError: No module named", mname)
247 self.msgout(4, "load_tail ->", m)
250 def ensure_fromlist(self, m, fromlist, recursive=0):
251 self.msg(4, "ensure_fromlist", m, fromlist, recursive)
255 all = self.find_all_submodules(m)
257 self.ensure_fromlist(m, all, 1)
260 submod = self.import_module(sub, subname, m)
264 def find_all_submodules(self, m):
279 self.msg(2, "can't list directory", dir)
292 def import_module(self, partname, fqname, parent):
293 self.msgin(3, "import_module", partname, fqname, parent)
295 m = self.modules[fqname]
299 self.msgout(3, "import_module ->", m)
301 if fqname in self.badmodules:
302 self.msgout(3, "import_module -> None")
305 self.msgout(3, "import_module -> None")
308 fp, pathname, stuff = self.find_module(partname,
311 self.msgout(3, "import_module ->", None)
315 m = self.load_module(fqname, fp, pathname, stuff)
321 self.msgout(3, "import_module ->", m)
324 def load_module(self, fqname, fp, pathname, file_info):
326 self.msgin(2, "load_module", fqname, fp and "fp", pathname)
328 m = self.load_package(fqname, pathname)
329 self.msgout(2, "load_module ->", m)
338 self.msgout(2, "raise ImportError: " + str(exc), pathname)
343 m = self.add_module(fqname)
346 if self.replace_paths:
347 co = self.replace_paths_in_code(co)
349 self.scan_code(co, m)
350 self.msgout(2, "load_module ->", m)
353 def _add_badmodule(self, name, caller):
354 if name not in self.badmodules:
355 self.badmodules[name] = {}
357 self.badmodules[name][caller.__name__] = 1
359 self.badmodules[name]["-"] = 1
361 def _safe_import_hook(self, name, caller, fromlist, level=-1):
362 # wrapper for self.import_hook() that won't raise ImportError
363 if name in self.badmodules:
364 self._add_badmodule(name, caller)
367 self.import_hook(name, caller, level=level)
369 self.msg(2, "ImportError:", str(msg))
370 self._add_badmodule(name, caller)
372 self.msg(2, "SyntaxError:", str(msg))
373 self._add_badmodule(name, caller)
378 if fullname in self.badmodules:
379 self._add_badmodule(fullname, caller)
382 self.import_hook(name, caller, [sub], level=level)
384 self.msg(2, "ImportError:", str(msg))
385 self._add_badmodule(fullname, caller)
387 def scan_opcodes(self, co):
397 def scan_code(self, co, m):
399 scanner = self.scan_opcodes
411 self._safe_import_hook(name, m, fromlist, level=0)
421 mm = self.modules.get(m.__name__ + "." + name)
423 mm = self.modules.get(name)
434 self._safe_import_hook(name, m, fromlist, level=level)
436 parent = self.determine_parent(m, level=level)
437 self._safe_import_hook(parent.__name__, None, fromlist, level=0)
444 self.scan_code(c, m)
446 def load_package(self, fqname, pathname):
447 self.msgin(2, "load_package", fqname, pathname)
451 m = self.add_module(fqname)
458 fp, buf, stuff = self.find_module("__init__", m.__path__)
460 self.load_module(fqname, fp, buf, stuff)
461 self.msgout(2, "load_package ->", m)
467 def add_module(self, fqname):
468 if fqname in self.modules:
469 return self.modules[fqname]
470 self.modules[fqname] = m = Module(fqname)
473 def find_module(self, name, path, parent=None):
479 if fullname in self.excludes:
480 self.msgout(3, "find_module -> Excluded", fullname)
487 path = self.path
491 def report(self):
499 keys = sorted(self.modules.keys())
501 m = self.modules[key]
509 missing, maybe = self.any_missing_maybe()
514 mods = sorted(self.badmodules[name].keys())
522 mods = sorted(self.badmodules[name].keys())
525 def any_missing(self):
530 missing, maybe = self.any_missing_maybe()
533 def any_missing_maybe(self):
544 for name in self.badmodules:
545 if name in self.excludes:
553 pkg = self.modules.get(pkgname)
555 if pkgname in self.badmodules[name]:
579 def replace_paths_in_code(self, co):
581 for f, r in self.replace_paths:
586 if self.debug and original_filename not in self.processed_paths:
588 self.msgout(2, "co_filename %r changed to %r" \
591 self.msgout(2, "co_filename %r remains unchanged" \
593 self.processed_paths.append(original_filename)
598 consts[i] = self.replace_paths_in_code(consts[i])