Mini Shell
"""IPython extension to reload modules before executing user code.
``autoreload`` reloads modules automatically before entering the execution of
code typed at the IPython prompt.
This makes for example the following workflow possible:
.. sourcecode:: ipython
In [1]: %load_ext autoreload
In [2]: %autoreload 2
In [3]: from foo import some_function
In [4]: some_function()
Out[4]: 42
In [5]: # open foo.py in an editor and change some_function to return 43
In [6]: some_function()
Out[6]: 43
The module was reloaded without reloading it explicitly, and the object
imported with ``from foo import ...`` was also updated.
Usage
=====
The following magic commands are provided:
``%autoreload``, ``%autoreload now``
Reload all modules (except those excluded by ``%aimport``)
automatically now.
``%autoreload 0``, ``%autoreload off``
Disable automatic reloading.
``%autoreload 1``, ``%autoreload explicit``
Reload all modules imported with ``%aimport`` every time before
executing the Python code typed.
``%autoreload 2``, ``%autoreload all``
Reload all modules (except those excluded by ``%aimport``) every
time before executing the Python code typed.
``%autoreload 3``, ``%autoreload complete``
Same as 2/all, but also adds any new objects in the module. See
unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects
Adding ``--print`` or ``-p`` to the ``%autoreload`` line will print autoreload activity to
standard out. ``--log`` or ``-l`` will do it to the log at INFO level; both can be used
simultaneously.
``%aimport``
List modules which are to be automatically imported or not to be imported.
``%aimport foo``
Import module 'foo' and mark it to be autoreloaded for ``%autoreload 1``
``%aimport foo, bar``
Import modules 'foo', 'bar' and mark them to be autoreloaded for ``%autoreload 1``
``%aimport -foo``
Mark module 'foo' to not be autoreloaded.
Caveats
=======
Reloading Python modules in a reliable way is in general difficult,
and unexpected things may occur. ``%autoreload`` tries to work around
common pitfalls by replacing function code objects and parts of
classes previously in the module with new versions. This makes the
following things to work:
- Functions and classes imported via 'from xxx import foo' are upgraded
to new versions when 'xxx' is reloaded.
- Methods and properties of classes are upgraded on reload, so that
calling 'c.foo()' on an object 'c' created before the reload causes
the new code for 'foo' to be executed.
Some of the known remaining caveats are:
- Replacing code objects does not always succeed: changing a @property
in a class to an ordinary method or a method to a member variable
can cause problems (but in old objects only).
- Functions that are removed (eg. via monkey-patching) from a module
before it is reloaded are not upgraded.
- C extension modules cannot be reloaded, and so cannot be autoreloaded.
- While comparing Enum and Flag, the 'is' Identity Operator is used (even in the case '==' has been used (Similar to the 'None' keyword)).
- Reloading a module, or importing the same module by a different name, creates new Enums. These may look the same, but are not.
"""
from IPython.core import magic_arguments
from IPython.core.magic import Magics, magics_class, line_magic
__skip_doctest__ = True
# -----------------------------------------------------------------------------
# Copyright (C) 2000 Thomas Heller
# Copyright (C) 2008 Pauli Virtanen <pav@iki.fi>
# Copyright (C) 2012 The IPython Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
# -----------------------------------------------------------------------------
#
# This IPython module is written by Pauli Virtanen, based on the autoreload
# code by Thomas Heller.
# -----------------------------------------------------------------------------
# Imports
# -----------------------------------------------------------------------------
import os
import sys
import traceback
import types
import weakref
import gc
import logging
from importlib import import_module, reload
from importlib.util import source_from_cache
# ------------------------------------------------------------------------------
# Autoreload functionality
# ------------------------------------------------------------------------------
class ModuleReloader:
enabled = False
"""Whether this reloader is enabled"""
check_all = True
"""Autoreload all modules, not just those listed in 'modules'"""
autoload_obj = False
"""Autoreload all modules AND autoload all new objects"""
def __init__(self, shell=None):
# Modules that failed to reload: {module: mtime-on-failed-reload, ...}
self.failed = {}
# Modules specially marked as autoreloadable.
self.modules = {}
# Modules specially marked as not autoreloadable.
self.skip_modules = {}
# (module-name, name) -> weakref, for replacing old code objects
self.old_objects = {}
# Module modification timestamps
self.modules_mtimes = {}
self.shell = shell
# Reporting callable for verbosity
self._report = lambda msg: None # by default, be quiet.
# Cache module modification times
self.check(check_all=True, do_reload=False)
# To hide autoreload errors
self.hide_errors = False
def mark_module_skipped(self, module_name):
"""Skip reloading the named module in the future"""
try:
del self.modules[module_name]
except KeyError:
pass
self.skip_modules[module_name] = True
def mark_module_reloadable(self, module_name):
"""Reload the named module in the future (if it is imported)"""
try:
del self.skip_modules[module_name]
except KeyError:
pass
self.modules[module_name] = True
def aimport_module(self, module_name):
"""Import a module, and mark it reloadable
Returns
-------
top_module : module
The imported module if it is top-level, or the top-level
top_name : module
Name of top_module
"""
self.mark_module_reloadable(module_name)
import_module(module_name)
top_name = module_name.split(".")[0]
top_module = sys.modules[top_name]
return top_module, top_name
def filename_and_mtime(self, module):
if not hasattr(module, "__file__") or module.__file__ is None:
return None, None
if getattr(module, "__name__", None) in [None, "__mp_main__", "__main__"]:
# we cannot reload(__main__) or reload(__mp_main__)
return None, None
filename = module.__file__
path, ext = os.path.splitext(filename)
if ext.lower() == ".py":
py_filename = filename
else:
try:
py_filename = source_from_cache(filename)
except ValueError:
return None, None
try:
pymtime = os.stat(py_filename).st_mtime
except OSError:
return None, None
return py_filename, pymtime
def check(self, check_all=False, do_reload=True):
"""Check whether some modules need to be reloaded."""
if not self.enabled and not check_all:
return
if check_all or self.check_all:
modules = list(sys.modules.keys())
else:
modules = list(self.modules.keys())
for modname in modules:
m = sys.modules.get(modname, None)
if modname in self.skip_modules:
continue
py_filename, pymtime = self.filename_and_mtime(m)
if py_filename is None:
continue
try:
if pymtime <= self.modules_mtimes[modname]:
continue
except KeyError:
self.modules_mtimes[modname] = pymtime
continue
else:
if self.failed.get(py_filename, None) == pymtime:
continue
self.modules_mtimes[modname] = pymtime
# If we've reached this point, we should try to reload the module
if do_reload:
self._report(f"Reloading '{modname}'.")
try:
if self.autoload_obj:
superreload(m, reload, self.old_objects, self.shell)
else:
superreload(m, reload, self.old_objects)
if py_filename in self.failed:
del self.failed[py_filename]
except:
if not self.hide_errors:
print(
"[autoreload of {} failed: {}]".format(
modname, traceback.format_exc(10)
),
file=sys.stderr,
)
self.failed[py_filename] = pymtime
# ------------------------------------------------------------------------------
# superreload
# ------------------------------------------------------------------------------
func_attrs = [
"__code__",
"__defaults__",
"__doc__",
"__closure__",
"__globals__",
"__dict__",
]
def update_function(old, new):
"""Upgrade the code object of a function"""
for name in func_attrs:
try:
setattr(old, name, getattr(new, name))
except (AttributeError, TypeError):
pass
def update_instances(old, new):
"""Use garbage collector to find all instances that refer to the old
class definition and update their __class__ to point to the new class
definition"""
refs = gc.get_referrers(old)
for ref in refs:
if type(ref) is old:
object.__setattr__(ref, "__class__", new)
def update_class(old, new):
"""Replace stuff in the __dict__ of a class, and upgrade
method code objects, and add new methods, if any"""
for key in list(old.__dict__.keys()):
old_obj = getattr(old, key)
try:
new_obj = getattr(new, key)
# explicitly checking that comparison returns True to handle
# cases where `==` doesn't return a boolean.
if (old_obj == new_obj) is True:
continue
except AttributeError:
# obsolete attribute: remove it
try:
delattr(old, key)
except (AttributeError, TypeError):
pass
continue
except ValueError:
# can't compare nested structures containing
# numpy arrays using `==`
pass
if update_generic(old_obj, new_obj):
continue
try:
setattr(old, key, getattr(new, key))
except (AttributeError, TypeError):
pass # skip non-writable attributes
for key in list(new.__dict__.keys()):
if key not in list(old.__dict__.keys()):
try:
setattr(old, key, getattr(new, key))
except (AttributeError, TypeError):
pass # skip non-writable attributes
# update all instances of class
update_instances(old, new)
def update_property(old, new):
"""Replace get/set/del functions of a property"""
update_generic(old.fdel, new.fdel)
update_generic(old.fget, new.fget)
update_generic(old.fset, new.fset)
def isinstance2(a, b, typ):
return isinstance(a, typ) and isinstance(b, typ)
UPDATE_RULES = [
(lambda a, b: isinstance2(a, b, type), update_class),
(lambda a, b: isinstance2(a, b, types.FunctionType), update_function),
(lambda a, b: isinstance2(a, b, property), update_property),
]
UPDATE_RULES.extend(
[
(
lambda a, b: isinstance2(a, b, types.MethodType),
lambda a, b: update_function(a.__func__, b.__func__),
),
]
)
def update_generic(a, b):
for type_check, update in UPDATE_RULES:
if type_check(a, b):
update(a, b)
return True
return False
class StrongRef:
def __init__(self, obj):
self.obj = obj
def __call__(self):
return self.obj
mod_attrs = [
"__name__",
"__doc__",
"__package__",
"__loader__",
"__spec__",
"__file__",
"__cached__",
"__builtins__",
]
def append_obj(module, d, name, obj, autoload=False):
in_module = hasattr(obj, "__module__") and obj.__module__ == module.__name__
if autoload:
# check needed for module global built-ins
if not in_module and name in mod_attrs:
return False
else:
if not in_module:
return False
key = (module.__name__, name)
try:
d.setdefault(key, []).append(weakref.ref(obj))
except TypeError:
pass
return True
def superreload(module, reload=reload, old_objects=None, shell=None):
"""Enhanced version of the builtin reload function.
superreload remembers objects previously in the module, and
- upgrades the class dictionary of every old class in the module
- upgrades the code object of every old function and method
- clears the module's namespace before reloading
"""
if old_objects is None:
old_objects = {}
# collect old objects in the module
for name, obj in list(module.__dict__.items()):
if not append_obj(module, old_objects, name, obj):
continue
key = (module.__name__, name)
try:
old_objects.setdefault(key, []).append(weakref.ref(obj))
except TypeError:
pass
# reload module
try:
# clear namespace first from old cruft
old_dict = module.__dict__.copy()
old_name = module.__name__
module.__dict__.clear()
module.__dict__["__name__"] = old_name
module.__dict__["__loader__"] = old_dict["__loader__"]
except (TypeError, AttributeError, KeyError):
pass
try:
module = reload(module)
except:
# restore module dictionary on failed reload
module.__dict__.update(old_dict)
raise
# iterate over all objects and update functions & classes
for name, new_obj in list(module.__dict__.items()):
key = (module.__name__, name)
if key not in old_objects:
# here 'shell' acts both as a flag and as an output var
if (
shell is None
or name == "Enum"
or not append_obj(module, old_objects, name, new_obj, True)
):
continue
shell.user_ns[name] = new_obj
new_refs = []
for old_ref in old_objects[key]:
old_obj = old_ref()
if old_obj is None:
continue
new_refs.append(old_ref)
update_generic(old_obj, new_obj)
if new_refs:
old_objects[key] = new_refs
else:
del old_objects[key]
return module
# ------------------------------------------------------------------------------
# IPython connectivity
# ------------------------------------------------------------------------------
@magics_class
class AutoreloadMagics(Magics):
def __init__(self, *a, **kw):
super().__init__(*a, **kw)
self._reloader = ModuleReloader(self.shell)
self._reloader.check_all = False
self._reloader.autoload_obj = False
self.loaded_modules = set(sys.modules)
@line_magic
@magic_arguments.magic_arguments()
@magic_arguments.argument(
"mode",
type=str,
default="now",
nargs="?",
help="""blank or 'now' - Reload all modules (except those excluded by %%aimport)
automatically now.
'0' or 'off' - Disable automatic reloading.
'1' or 'explicit' - Reload only modules imported with %%aimport every
time before executing the Python code typed.
'2' or 'all' - Reload all modules (except those excluded by %%aimport)
every time before executing the Python code typed.
'3' or 'complete' - Same as 2/all, but also but also adds any new
objects in the module.
""",
)
@magic_arguments.argument(
"-p",
"--print",
action="store_true",
default=False,
help="Show autoreload activity using `print` statements",
)
@magic_arguments.argument(
"-l",
"--log",
action="store_true",
default=False,
help="Show autoreload activity using the logger",
)
@magic_arguments.argument(
"--hide-errors",
action="store_true",
default=False,
help="Hide autoreload errors",
)
def autoreload(self, line=""):
r"""%autoreload => Reload modules automatically
%autoreload or %autoreload now
Reload all modules (except those excluded by %aimport) automatically
now.
%autoreload 0 or %autoreload off
Disable automatic reloading.
%autoreload 1 or %autoreload explicit
Reload only modules imported with %aimport every time before executing
the Python code typed.
%autoreload 2 or %autoreload all
Reload all modules (except those excluded by %aimport) every time
before executing the Python code typed.
%autoreload 3 or %autoreload complete
Same as 2/all, but also but also adds any new objects in the module. See
unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects
The optional arguments --print and --log control display of autoreload activity. The default
is to act silently; --print (or -p) will print out the names of modules that are being
reloaded, and --log (or -l) outputs them to the log at INFO level.
The optional argument --hide-errors hides any errors that can happen when trying to
reload code.
Reloading Python modules in a reliable way is in general
difficult, and unexpected things may occur. %autoreload tries to
work around common pitfalls by replacing function code objects and
parts of classes previously in the module with new versions. This
makes the following things to work:
- Functions and classes imported via 'from xxx import foo' are upgraded
to new versions when 'xxx' is reloaded.
- Methods and properties of classes are upgraded on reload, so that
calling 'c.foo()' on an object 'c' created before the reload causes
the new code for 'foo' to be executed.
Some of the known remaining caveats are:
- Replacing code objects does not always succeed: changing a @property
in a class to an ordinary method or a method to a member variable
can cause problems (but in old objects only).
- Functions that are removed (eg. via monkey-patching) from a module
before it is reloaded are not upgraded.
- C extension modules cannot be reloaded, and so cannot be
autoreloaded.
"""
args = magic_arguments.parse_argstring(self.autoreload, line)
mode = args.mode.lower()
p = print
logger = logging.getLogger("autoreload")
l = logger.info
def pl(msg):
p(msg)
l(msg)
if args.print is False and args.log is False:
self._reloader._report = lambda msg: None
elif args.print is True:
if args.log is True:
self._reloader._report = pl
else:
self._reloader._report = p
elif args.log is True:
self._reloader._report = l
self._reloader.hide_errors = args.hide_errors
if mode == "" or mode == "now":
self._reloader.check(True)
elif mode == "0" or mode == "off":
self._reloader.enabled = False
elif mode == "1" or mode == "explicit":
self._reloader.enabled = True
self._reloader.check_all = False
self._reloader.autoload_obj = False
elif mode == "2" or mode == "all":
self._reloader.enabled = True
self._reloader.check_all = True
self._reloader.autoload_obj = False
elif mode == "3" or mode == "complete":
self._reloader.enabled = True
self._reloader.check_all = True
self._reloader.autoload_obj = True
else:
raise ValueError(f'Unrecognized autoreload mode "{mode}".')
@line_magic
def aimport(self, parameter_s="", stream=None):
"""%aimport => Import modules for automatic reloading.
%aimport
List modules to automatically import and not to import.
%aimport foo
Import module 'foo' and mark it to be autoreloaded for %autoreload explicit
%aimport foo, bar
Import modules 'foo', 'bar' and mark them to be autoreloaded for %autoreload explicit
%aimport -foo, bar
Mark module 'foo' to not be autoreloaded for %autoreload explicit, all, or complete, and 'bar'
to be autoreloaded for mode explicit.
"""
modname = parameter_s
if not modname:
to_reload = sorted(self._reloader.modules.keys())
to_skip = sorted(self._reloader.skip_modules.keys())
if stream is None:
stream = sys.stdout
if self._reloader.check_all:
stream.write("Modules to reload:\nall-except-skipped\n")
else:
stream.write("Modules to reload:\n%s\n" % " ".join(to_reload))
stream.write("\nModules to skip:\n%s\n" % " ".join(to_skip))
else:
for _module in [_.strip() for _ in modname.split(",")]:
if _module.startswith("-"):
_module = _module[1:].strip()
self._reloader.mark_module_skipped(_module)
else:
top_module, top_name = self._reloader.aimport_module(_module)
# Inject module to user namespace
self.shell.push({top_name: top_module})
def pre_run_cell(self, info):
if self._reloader.enabled:
try:
self._reloader.check()
except:
pass
def post_execute_hook(self):
"""Cache the modification times of any modules imported in this execution"""
newly_loaded_modules = set(sys.modules) - self.loaded_modules
for modname in newly_loaded_modules:
_, pymtime = self._reloader.filename_and_mtime(sys.modules[modname])
if pymtime is not None:
self._reloader.modules_mtimes[modname] = pymtime
self.loaded_modules.update(newly_loaded_modules)
def load_ipython_extension(ip):
"""Load the extension in IPython."""
auto_reload = AutoreloadMagics(ip)
ip.register_magics(auto_reload)
ip.events.register("pre_run_cell", auto_reload.pre_run_cell)
ip.events.register("post_execute", auto_reload.post_execute_hook)
Zerion Mini Shell 1.0