Skip to content

C
cpython
Commit cef2098c authored by Guido van Rossum's avatar Guido van Rossum
Browse files
Options

Moving xreload to the sandbox for now.

parent e27dc723
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 293 deletions
Lib/test/test_xreload.py deleted 100644 → 0
View file @ e27dc723
"""Doctests for module reloading.
>>> from xreload import xreload
>>> from test.test_xreload import make_mod
>>> make_mod()
>>> import x
>>> C = x.C
>>> Cfoo = C.foo
>>> Cbar = C.bar
>>> Cstomp = C.stomp
>>> b = C()
>>> bfoo = b.foo
>>> b.foo()
42
>>> bfoo()
42
>>> Cfoo(b)
42
>>> Cbar()
42 42
>>> Cstomp()
42 42 42
>>> make_mod(repl="42", subst="24")
>>> xreload(x)
<module 'x' (built-in)>
>>> b.foo()
24
>>> bfoo()
24
>>> Cfoo(b)
24
>>> Cbar()
24 24
>>> Cstomp()
24 24 24
"""
SAMPLE_CODE = """
class C:
def foo(self):
print(42)
@classmethod
def bar(cls):
print(42, 42)
@staticmethod
def stomp():
print (42, 42, 42)
"""
import os
import sys
import shutil
import doctest
import xreload
import tempfile
from test.test_support import run_unittest
tempdir = None
save_path = None
def setUp(unused=None):
global tempdir, save_path
tempdir = tempfile.mkdtemp()
save_path = list(sys.path)
sys.path.append(tempdir)
def tearDown(unused=None):
global tempdir, save_path
if save_path is not None:
sys.path = save_path
save_path = None
if tempdir is not None:
shutil.rmtree(tempdir)
tempdir = None
def make_mod(name="x", repl=None, subst=None):
if not tempdir:
setUp()
assert tempdir
fn = os.path.join(tempdir, name + ".py")
f = open(fn, "w")
sample = SAMPLE_CODE
if repl is not None and subst is not None:
sample = sample.replace(repl, subst)
try:
f.write(sample)
finally:
f.close()
def test_suite():
return doctest.DocTestSuite(setUp=setUp, tearDown=tearDown)
def test_main():
run_unittest(test_suite())
if __name__ == "__main__":
test_main()
Lib/xreload.py deleted 100644 → 0
View file @ e27dc723
"""Alternative to reload().
This works by executing the module in a scratch namespace, and then
patching classes, methods and functions in place. This avoids the
need to patch instances. New objects are copied into the target
namespace.
Some of the many limitiations include:
- Global mutable objects other than classes are simply replaced, not patched
- Code using metaclasses is not handled correctly
- Code creating global singletons is not handled correctly
- Functions and methods using decorators (other than classmethod and
staticmethod) is not handled correctly
- Renamings are not handled correctly
- Dependent modules are not reloaded
- When a dependent module contains 'from foo import bar', and
reloading foo deletes foo.bar, the dependent module continues to use
the old foo.bar object rather than failing
- Frozen modules and modules loaded from zip files aren't handled
correctly
- Classes involving __slots__ are not handled correctly
"""
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?
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. We copy the module dict to a temporary; then
# clear the module dict; then execute the new code in the module
# dict; then swap things back and around. This trick (due to
# Glyph Lefkowitz) ensures that the (readonly) __globals__
# attribute of methods and functions is set to the correct dict
# object.
tmpns = modns.copy()
modns.clear()
modns["__name__"] = tmpns["__name__"]
exec(code, modns)
# Now we get to the hard part
oldnames = set(tmpns)
newnames = set(modns)
# Update attributes in place
for name in oldnames & newnames:
modns[name] = _update(tmpns[name], modns[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 oldobj is newobj:
# Probably something imported
return 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)
if isinstance(newobj, classmethod):
return _update_classmethod(oldobj, newobj)
if isinstance(newobj, staticmethod):
return _update_staticmethod(oldobj, newobj)
# Not something we recognize, just give up
return newobj
# All of the following functions have the same signature as _update()
def _update_function(oldfunc, newfunc):
"""Update a function object."""
oldfunc.__doc__ = newfunc.__doc__
oldfunc.__dict__.update(newfunc.__dict__)
oldfunc.__code__ = newfunc.__code__
oldfunc.__defaults__ = newfunc.__defaults__
return oldfunc
def _update_method(oldmeth, newmeth):
"""Update a method object."""
# XXX What if im_func is not a function?
_update(oldmeth.im_func, newmeth.im_func)
return oldmeth
def _update_class(oldclass, newclass):
"""Update a class object."""
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, _update(olddict[name], newdict[name]))
return oldclass
def _update_classmethod(oldcm, newcm):
"""Update a classmethod update."""
# While we can't modify the classmethod object itself (it has no
# mutable attributes), we *can* extract the underlying function
# (by calling __get__(), which returns a method object) and update
# it in-place. We don't have the class available to pass to
# __get__() but any object except None will do.
_update(oldcm.__get__(0), newcm.__get__(0))
return newcm
def _update_staticmethod(oldsm, newsm):
"""Update a staticmethod update."""
# While we can't modify the staticmethod object itself (it has no
# mutable attributes), we *can* extract the underlying function
# (by calling __get__(), which returns it) and update it in-place.
# We don't have the class available to pass to __get__() but any
# object except None will do.
_update(oldsm.__get__(0), newsm.__get__(0))
return newsm
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7