##// END OF EJS Templates
[merge] Merging Gael's ipython-sync-frontend WX branch....
[merge] Merging Gael's ipython-sync-frontend WX branch. Original branch location: https://code.launchpad.net/~gael-varoquaux/ipython/ipython-sync-frontend

File last commit:

r1853:b8f5152c
r2095:15d76858 merge
Show More
deep_reload.py
182 lines | 5.6 KiB | text/x-python | PythonLexer
Ville M. Vainio
crlf -> lf
r1032 # -*- coding: utf-8 -*-
"""
A module to change reload() so that it acts recursively.
To enable it type:
>>> import __builtin__, deep_reload
>>> __builtin__.reload = deep_reload.reload
Fernando Perez
Fixes to testing....
r1376
Ville M. Vainio
crlf -> lf
r1032 You can then disable it with:
>>> __builtin__.reload = deep_reload.original_reload
Alternatively, you can add a dreload builtin alongside normal reload with:
>>> __builtin__.dreload = deep_reload.reload
This code is almost entirely based on knee.py from the standard library.
Fernando Perez
Remove svn-style $Id marks from docstrings and Release imports....
r1853 """
Ville M. Vainio
crlf -> lf
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
Do not crash on from __future__ import absolute_import. Close #244.
r1142 def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
# For now level is ignored, it's just there to prevent crash
# with from __future__ import absolute_import
Ville M. Vainio
crlf -> lf
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)
#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:
return sys.modules[fqname]
except KeyError:
pass
print 'Reloading', fqname #, sys.excepthook is sys.__excepthook__, \
#sys.displayhook is sys.__displayhook__
found_now[fqname] = 1
try:
fp, pathname, stuff = imp.find_module(partname,
parent and parent.__path__)
except ImportError:
return None
try:
m = imp.load_module(fqname, fp, pathname, stuff)
finally:
if fp: fp.close()
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
original_reload = __builtin__.reload
# 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
list contains sys, __main__, and __builtin__, to prevent, e.g., resetting
display, exception, and io hooks.
"""
global found_now
for i in exclude:
found_now[i] = 1
original_import = __builtin__.__import__
__builtin__.__import__ = deep_import_hook
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