allow type of already existing class instances to be updated

IPython/extensions/autoreload.py

@@ -115,6 +115,7 b' import sys'
 import traceback
 import types
 import weakref
+import inspect
 from importlib import import_module
 from importlib.util import source_from_cache
 from imp import reload
@@ -267,6 +268,54 b' def update_function(old, new):'
             pass
 
 
+def update_instances(old, new, objects=None):
+    """Iterate through objects recursively, searching for instances of old and
+    replace their __class__ reference with new. If no objects are given, start 
+    with the current ipython workspace.
+    """
+    if not objects:
+        # find ipython workspace stack frame
+        frame = next(frame_nfo.frame for frame_nfo in inspect.stack() 
+                     if 'trigger' in frame_nfo.function)
+        # build generator for non-private variable values from workspace
+        shell = frame.f_locals['self'].shell
+        user_ns = shell.user_ns
+        user_ns_hidden = shell.user_ns_hidden
+        nonmatching = object()
+        objects = ( value for key, value in user_ns.items()
+                if not key.startswith('_') 
+                and (value is not user_ns_hidden.get(key, nonmatching)) 
+                and not inspect.ismodule(value))
+    
+    # use dict values if objects is a dict but don't touch private variables
+    if hasattr(objects, 'items'):
+        objects = (value for key, value in objects.items()
+                       if not str(key).startswith('_')
+                       and not inspect.ismodule(value) )
+
+    # try if objects is iterable
+    try:
+        for obj in objects:
+
+            # update, if object is instance of old_class (but no subclasses)
+            if type(obj) is old:
+                obj.__class__ = new
+                
+
+            # if object is instance of other class, look for nested instances
+            if hasattr(obj, '__dict__') and not (inspect.isfunction(obj)
+                                                 or inspect.ismethod(obj)):
+                update_instances(old, new, obj.__dict__)
+
+            # if object is a container, search it
+            if hasattr(obj, 'items') or (hasattr(obj, '__contains__')
+                                         and not isinstance(obj, str)):
+                update_instances(old, new, obj)
+
+    except TypeError:
+        pass
+
+        
 def update_class(old, new):
     """Replace stuff in the __dict__ of a class, and upgrade
     method code objects, and add new methods, if any"""
@@ -300,6 +349,9 b' def update_class(old, new):'
             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"""