Add new '%autoreload 3' option

Example: When an IPython session is ran with the 'autoreload' extension,
you will now have the option '3' to select which means the following:

    1. replicate all functionality from option 2
    2. autoload all new funcs/classes/enums/globals from the module
        when they're added
    3. autoload all newly imported funcs/classes/enums/globals
        from external modules

Try ``%autoreload 3`` in an IPython session
after running ``%load_ext autoreload``

For more information please see unit test -
extensions/tests/test_autoreload.py : 'test_autoload_newly_added_objects'

docs/source/whatsnew/pr/autoreload-option-3-feature.rst

@@ -0,0 +1,14 b''
+Autoreload 3 feature
+====================
+
+Example: When an IPython session is ran with the 'autoreload' extension loaded,
+you will now have the option '3' to select which means the following:
+
+    1. replicate all functionality from option 2
+    2. autoload all new funcs/classes/enums/globals from the module when they're added
+    3. autoload all newly imported funcs/classes/enums/globals from external modules
+
+Try ``%autoreload 3`` in an IPython session after running ``%load_ext autoreload``
+
+For more information please see unit test - 
+    extensions/tests/test_autoreload.py : 'test_autoload_newly_added_objects'

IPython/extensions/autoreload.py

@@ -48,6 +48,12 b' The following magic commands are provided:'
     Reload all modules (except those excluded by ``%aimport``) every
     time before executing the Python code typed.
 
+``%autoreload 3``
+
+    Reload all modules AND autoload newly added objects
+        (except those excluded by ``%aimport``)
+    every time before executing the Python code typed.
+
 ``%aimport``
 
     List modules which are to be automatically imported or not to be imported.
@@ -131,7 +137,10 b' class ModuleReloader(object):'
     check_all = True
     """Autoreload all modules, not just those listed in 'modules'"""
 
-    def __init__(self):
+    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.
@@ -142,6 +151,7 b' class ModuleReloader(object):'
         self.old_objects = {}
         # Module modification timestamps
         self.modules_mtimes = {}
+        self.shell = shell
 
         # Cache module modification times
         self.check(check_all=True, do_reload=False)
@@ -242,6 +252,9 b' class ModuleReloader(object):'
             # If we've reached this point, we should try to reload the module
             if do_reload:
                 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]
@@ -356,7 +369,25 b' class StrongRef(object):'
         return self.obj
 
 
-def superreload(module, reload=reload, old_objects=None):
+def append_obj(module, d, name, obj, autoload=False):
+    not_in_mod = not hasattr(obj, '__module__') or obj.__module__ != module.__name__
+    if autoload:
+        # check needed for module global built-ins (int, str, dict,..)
+        if name.startswith('__') and not_in_mod:
+            return False
+    else:
+        if not_in_mod:
+            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
@@ -371,7 +402,7 b' def superreload(module, reload=reload, old_objects=None):'
 
     # collect old objects in the module
     for name, obj in list(module.__dict__.items()):
-        if not hasattr(obj, '__module__') or obj.__module__ != module.__name__:
+        if not append_obj(module, old_objects, name, obj):
             continue
         key = (module.__name__, name)
         try:
@@ -400,7 +431,15 b' def superreload(module, reload=reload, old_objects=None):'
     # 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: continue
+        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]:
@@ -426,8 +465,9 b' from IPython.core.magic import Magics, magics_class, line_magic'
 class AutoreloadMagics(Magics):
     def __init__(self, *a, **kw):
         super(AutoreloadMagics, self).__init__(*a, **kw)
-        self._reloader = ModuleReloader()
+        self._reloader = ModuleReloader(self.shell)
         self._reloader.check_all = False
+        self._reloader.autoload_obj = False
         self.loaded_modules = set(sys.modules)
 
     @line_magic
@@ -485,6 +525,11 b' class AutoreloadMagics(Magics):'
         elif parameter_s == '2':
             self._reloader.check_all = True
             self._reloader.enabled = True
+            self._reloader.enabled = True
+        elif parameter_s == '3':
+            self._reloader.check_all = True
+            self._reloader.enabled = True
+            self._reloader.autoload_obj = True
 
     @line_magic
     def aimport(self, parameter_s='', stream=None):

IPython/extensions/tests/test_autoreload.py

@@ -252,6 +252,89 b' class TestAutoreload(Fixture):'
             with nt.assert_raises(AttributeError):
                 self.shell.run_code("{object_name}.toto".format(object_name=object_name))
 
+    def test_autoload_newly_added_objects(self):
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"from {mod_name} import *")
+        self.shell.run_code("func1()")
+        with nt.assert_raises(NameError):
+            self.shell.run_code('func2()')
+        with nt.assert_raises(NameError):
+            self.shell.run_code('t = Test()')
+        with nt.assert_raises(NameError):
+            self.shell.run_code('number')
+
+        # ----------- TEST NEW OBJ LOADED --------------------------
+
+        new_code = """
+        def func1(): pass
+        def func2(): pass
+        class Test: pass
+        number = 0
+        from enum import Enum
+        class TestEnum(Enum):
+            A = 'a'
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+
+        # test function now exists in shell's namespace namespace
+        self.shell.run_code("func2()")
+        # test function now exists in module's dict
+        self.shell.run_code(f"import sys; sys.modules['{mod_name}'].func2()")
+        # test class now exists
+        self.shell.run_code("t = Test()")
+        # test global built-in var now exists
+        self.shell.run_code('number')
+        # test the enumerations gets loaded succesfully
+        self.shell.run_code("TestEnum.A")
+
+        # ----------- TEST NEW OBJ CAN BE CHANGED --------------------
+
+        new_code = """
+        def func1(): return 'changed'
+        def func2(): return 'changed'
+        class Test:
+            def new_func(self):
+                return 'changed'
+        number = 1
+        from enum import Enum
+        class TestEnum(Enum):
+            A = 'a'
+            B = 'added'
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+        self.shell.run_code("assert func1() == 'changed'")
+        self.shell.run_code("assert func2() == 'changed'")
+        self.shell.run_code("t = Test(); assert t.new_func() == 'changed'")
+        self.shell.run_code("assert number == 1")
+        self.shell.run_code("assert TestEnum.B.value == 'added'")
+
+        # ----------- TEST IMPORT FROM MODULE --------------------------
+
+        new_mod_code = '''
+        from enum import Enum
+        class Ext(Enum):
+            A = 'ext'
+        def ext_func():
+            return 'ext'
+        class ExtTest:
+            def meth(self):
+                return 'ext'
+        ext_int = 2
+        '''
+        new_mod_name, new_mod_fn = self.new_module(textwrap.dedent(new_mod_code))
+        current_mod_code = f'''
+        from {new_mod_name} import *
+        '''
+        self.write_file(mod_fn, textwrap.dedent(current_mod_code))
+        self.shell.run_code("assert Ext.A.value == 'ext'")
+        self.shell.run_code("assert ext_func() == 'ext'")
+        self.shell.run_code("t = ExtTest(); assert t.meth() == 'ext'")
+        self.shell.run_code("assert ext_int == 2")
+
     def _check_smoketest(self, use_aimport=True):
         """
         Functional test for the automatic reloader using either