1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
"""Alternative to reload().
This works by executing the module in a scratch namespace, and then
patching classes, methods and functions. This avoids the need to
patch instances. New objects are copied into the target namespace.
"""
import imp
import sys
import types
def xreload(mod):
"""Reload a module in place, updating classes, methods and functions.
Args:
mod: a module object
Returns:
The (updated) input object itself.
"""
# Get the module name, e.g. 'foo.bar.whatever'
modname = mod.__name__
# Get the module namespace (dict) early; this is part of the type check
modns = mod.__dict__
# Parse it into package name and module name, e.g. 'foo.bar' and 'whatever'
i = modname.rfind(".")
if i >= 0:
pkgname, modname = modname[:i], modname[i+1:]
else:
pkgname = None
# Compute the search path
if pkgname:
# We're not reloading the package, only the module in it
pkg = sys.modules[pkgname]
path = pkg.__path__ # Search inside the package
else:
# Search the top-level module path
pkg = None
path = None # Make find_module() uses the default search path
# Find the module; may raise ImportError
(stream, filename, (suffix, mode, kind)) = imp.find_module(modname, path)
# Turn it into a code object
try:
# Is it Python source code or byte code read from a file?
# XXX Could handle frozen modules, zip-import modules
if kind not in (imp.PY_COMPILED, imp.PY_SOURCE):
# Fall back to built-in reload()
return reload(mod)
if kind == imp.PY_SOURCE:
source = stream.read()
code = compile(source, filename, "exec")
else:
code = marshal.load(stream)
finally:
if stream:
stream.close()
# Execute the code in a temporary namespace; if this fails, no changes
tmpns = {}
exec(code, tmpns)
# Now we get to the hard part
oldnames = set(modns)
newnames = set(tmpns)
# Add newly introduced names
for name in newnames - oldnames:
modns[name] = tmpns[name]
# Delete names that are no longer current
for name in oldnames - newnames - {"__name__"}:
del modns[name]
# Now update the rest in place
for name in oldnames & newnames:
modns[name] = _update(modns[name], tmpns[name])
# Done!
return mod
def _update(oldobj, newobj):
"""Update oldobj, if possible in place, with newobj.
If oldobj is immutable, this simply returns newobj.
Args:
oldobj: the object to be updated
newobj: the object used as the source for the update
Returns:
either oldobj, updated in place, or newobj.
"""
if type(oldobj) is not type(newobj):
# Cop-out: if the type changed, give up
return newobj
if hasattr(newobj, "__reload_update__"):
# Provide a hook for updating
return newobj.__reload_update__(oldobj)
if isinstance(newobj, types.ClassType):
return _update_class(oldobj, newobj)
if isinstance(newobj, types.FunctionType):
return _update_function(oldobj, newobj)
if isinstance(newobj, types.MethodType):
return _update_method(oldobj, newobj)
# XXX Support class methods, static methods, other decorators
# Not something we recognize, just give up
return newobj
def _update_function(oldfunc, newfunc):
"""Update a function object."""
oldfunc.__doc__ = newfunc.__doc__
oldfunc.__dict__.update(newfunc.__dict__)
oldfunc.func_code = newfunc.func_code
oldfunc.func_defaults = newfunc.func_defaults
# XXX What else?
return oldfunc
def _update_method(oldmeth, newmeth):
"""Update a method object."""
# XXX What if im_func is not a function?
_update_function(oldmeth.im_func, newmeth.im_func)
return oldmeth
def _update_class(oldclass, newclass):
"""Update a class object."""
# XXX What about __slots__?
olddict = oldclass.__dict__
newdict = newclass.__dict__
oldnames = set(olddict)
newnames = set(newdict)
for name in newnames - oldnames:
setattr(oldclass, name, newdict[name])
for name in oldnames - newnames:
delattr(oldclass, name)
for name in oldnames & newnames - {"__dict__", "__doc__"}:
setattr(oldclass, name, newdict[name])
return oldclass
|
