deepreload.py
188 lines
| 5.6 KiB
| text/x-python
|
PythonLexer
Ville M. Vainio
|
r1032 | # -*- coding: utf-8 -*- | ||
""" | ||||
A module to change reload() so that it acts recursively. | ||||
Brian Granger
|
r2499 | To enable it type:: | ||
Fernando Perez
|
r1376 | |||
Brian Granger
|
r2499 | import __builtin__, deepreload | ||
__builtin__.reload = deepreload.reload | ||||
You can then disable it with:: | ||||
__builtin__.reload = deepreload.original_reload | ||||
Bernardo B. Marques
|
r4872 | |||
Brian Granger
|
r2499 | Alternatively, you can add a dreload builtin alongside normal reload with:: | ||
__builtin__.dreload = deepreload.reload | ||||
Bernardo B. Marques
|
r4872 | |||
Ville M. Vainio
|
r1032 | This code is almost entirely based on knee.py from the standard library. | ||
Fernando Perez
|
r1853 | """ | ||
Ville M. Vainio
|
r1032 | |||
#***************************************************************************** | ||||
# Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu> | ||||
# | ||||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#***************************************************************************** | ||||
import __builtin__ | ||||
import imp | ||||
import sys | ||||
# Replacement for __import__() | ||||
Ville M. Vainio
|
r1142 | def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1): | ||
Bernardo B. Marques
|
r4872 | # For now level is ignored, it's just there to prevent crash | ||
Ville M. Vainio
|
r1142 | # with from __future__ import absolute_import | ||
Ville M. Vainio
|
r1032 | parent = determine_parent(globals) | ||
q, tail = find_head_package(parent, name) | ||||
m = load_tail(q, tail) | ||||
if not fromlist: | ||||
return q | ||||
if hasattr(m, "__path__"): | ||||
ensure_fromlist(m, fromlist) | ||||
return m | ||||
def determine_parent(globals): | ||||
if not globals or not globals.has_key("__name__"): | ||||
return None | ||||
pname = globals['__name__'] | ||||
if globals.has_key("__path__"): | ||||
parent = sys.modules[pname] | ||||
assert globals is parent.__dict__ | ||||
return parent | ||||
if '.' in pname: | ||||
i = pname.rfind('.') | ||||
pname = pname[:i] | ||||
parent = sys.modules[pname] | ||||
assert parent.__name__ == pname | ||||
return parent | ||||
return None | ||||
def find_head_package(parent, name): | ||||
# Import the first | ||||
if '.' in name: | ||||
# 'some.nested.package' -> head = 'some', tail = 'nested.package' | ||||
i = name.find('.') | ||||
head = name[:i] | ||||
tail = name[i+1:] | ||||
else: | ||||
# 'packagename' -> head = 'packagename', tail = '' | ||||
head = name | ||||
tail = "" | ||||
if parent: | ||||
# If this is a subpackage then qname = parent's name + head | ||||
qname = "%s.%s" % (parent.__name__, head) | ||||
else: | ||||
qname = head | ||||
q = import_module(head, qname, parent) | ||||
if q: return q, tail | ||||
if parent: | ||||
qname = head | ||||
parent = None | ||||
q = import_module(head, qname, parent) | ||||
if q: return q, tail | ||||
raise ImportError, "No module named " + qname | ||||
def load_tail(q, tail): | ||||
m = q | ||||
while tail: | ||||
i = tail.find('.') | ||||
if i < 0: i = len(tail) | ||||
head, tail = tail[:i], tail[i+1:] | ||||
# fperez: fix dotted.name reloading failures by changing: | ||||
#mname = "%s.%s" % (m.__name__, head) | ||||
# to: | ||||
mname = m.__name__ | ||||
# This needs more testing!!! (I don't understand this module too well) | ||||
Bernardo B. Marques
|
r4872 | |||
Ville M. Vainio
|
r1032 | #print '** head,tail=|%s|->|%s|, mname=|%s|' % (head,tail,mname) # dbg | ||
m = import_module(head, mname, m) | ||||
if not m: | ||||
raise ImportError, "No module named " + mname | ||||
return m | ||||
def ensure_fromlist(m, fromlist, recursive=0): | ||||
for sub in fromlist: | ||||
if sub == "*": | ||||
if not recursive: | ||||
try: | ||||
all = m.__all__ | ||||
except AttributeError: | ||||
pass | ||||
else: | ||||
ensure_fromlist(m, all, 1) | ||||
continue | ||||
if sub != "*" and not hasattr(m, sub): | ||||
subname = "%s.%s" % (m.__name__, sub) | ||||
submod = import_module(sub, subname, m) | ||||
if not submod: | ||||
raise ImportError, "No module named " + subname | ||||
# Need to keep track of what we've already reloaded to prevent cyclic evil | ||||
found_now = {} | ||||
def import_module(partname, fqname, parent): | ||||
global found_now | ||||
if found_now.has_key(fqname): | ||||
try: | ||||
Bernardo B. Marques
|
r4872 | return sys.modules[fqname] | ||
Ville M. Vainio
|
r1032 | except KeyError: | ||
pass | ||||
Bernardo B. Marques
|
r4872 | |||
Ville M. Vainio
|
r1032 | print 'Reloading', fqname #, sys.excepthook is sys.__excepthook__, \ | ||
#sys.displayhook is sys.__displayhook__ | ||||
Bernardo B. Marques
|
r4872 | |||
Ville M. Vainio
|
r1032 | found_now[fqname] = 1 | ||
try: | ||||
fp, pathname, stuff = imp.find_module(partname, | ||||
parent and parent.__path__) | ||||
except ImportError: | ||||
return None | ||||
Bernardo B. Marques
|
r4872 | |||
Ville M. Vainio
|
r1032 | try: | ||
m = imp.load_module(fqname, fp, pathname, stuff) | ||||
finally: | ||||
if fp: fp.close() | ||||
Bernardo B. Marques
|
r4872 | |||
Ville M. Vainio
|
r1032 | if parent: | ||
setattr(parent, partname, m) | ||||
return m | ||||
def deep_reload_hook(module): | ||||
name = module.__name__ | ||||
if '.' not in name: | ||||
return import_module(name, name, None) | ||||
i = name.rfind('.') | ||||
pname = name[:i] | ||||
parent = sys.modules[pname] | ||||
return import_module(name[i+1:], name, parent) | ||||
# Save the original hooks | ||||
Thomas Kluyver
|
r4753 | try: | ||
original_reload = __builtin__.reload | ||||
except AttributeError: | ||||
original_reload = imp.reload # Python 3 | ||||
Ville M. Vainio
|
r1032 | |||
# Replacement for reload() | ||||
def reload(module, exclude=['sys', '__builtin__', '__main__']): | ||||
"""Recursively reload all modules used in the given module. Optionally | ||||
takes a list of modules to exclude from reloading. The default exclude | ||||
Bernardo B. Marques
|
r4872 | list contains sys, __main__, and __builtin__, to prevent, e.g., resetting | ||
Ville M. Vainio
|
r1032 | display, exception, and io hooks. | ||
""" | ||||
global found_now | ||||
for i in exclude: | ||||
found_now[i] = 1 | ||||
original_import = __builtin__.__import__ | ||||
Bernardo B. Marques
|
r4872 | __builtin__.__import__ = deep_import_hook | ||
Ville M. Vainio
|
r1032 | try: | ||
ret = deep_reload_hook(module) | ||||
finally: | ||||
__builtin__.__import__ = original_import | ||||
found_now = {} | ||||
return ret | ||||
# Uncomment the following to automatically activate deep reloading whenever | ||||
# this module is imported | ||||
#__builtin__.reload = reload | ||||