Extension manager refuses to load extension more than once

IPython/core/extensions.py

@@ -23,6 +23,7 b' import sys'
 from urllib import urlretrieve
 from urlparse import urlparse
 
+from IPython.core.error import UsageError
 from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import Instance
 
@@ -44,10 +45,11 b' class ExtensionManager(Configurable):'
     the only argument.  You can do anything you want with IPython at
     that point, including defining new magic and aliases, adding new
     components, etc.
-
-    The :func:`load_ipython_extension` will be called again is you
-    load or reload the extension again.  It is up to the extension
-    author to add code to manage that.
+    
+    You can also optionaly define an :func:`unload_ipython_extension(ipython)`
+    function, which will be called if the user unloads or reloads the extension.
+    The extension manager will only call :func:`load_ipython_extension` again
+    if the extension is reloaded.
 
     You can put your extension modules anywhere you want, as long as
     they can be imported by Python's standard import mechanism.  However,
@@ -81,9 +83,12 b' class ExtensionManager(Configurable):'
     def load_extension(self, module_str):
         """Load an IPython extension by its module name.
 
-        If :func:`load_ipython_extension` returns anything, this function
-        will return that object.
+        Returns the string "already loaded" if the extension is already loaded,
+        otherwise None.
         """
+        if module_str in self.loaded:
+            return "already loaded"
+        
         from IPython.utils.syspathcontext import prepended_to_syspath
 
         if module_str not in sys.modules:
@@ -98,11 +103,20 b' class ExtensionManager(Configurable):'
 
         This function looks up the extension's name in ``sys.modules`` and
         simply calls ``mod.unload_ipython_extension(self)``.
+        
+        Returns the string "no unload function" if the extension doesn't define
+        a function to unload itself, "not loaded" if the extension isn't loaded,
+        otherwise None.
         """
+        if module_str not in self.loaded:
+            return "not loaded"
+        
         if module_str in sys.modules:
             mod = sys.modules[module_str]
             if self._call_unload_ipython_extension(mod):
                 self.loaded.discard(module_str)
+            else:
+                return "no unload function"
 
     def reload_extension(self, module_str):
         """Reload an IPython extension by calling reload.

IPython/core/magics/extension.py

@@ -59,14 +59,26 b' class ExtensionMagics(Magics):'
         """Load an IPython extension by its module name."""
         if not module_str:
             raise UsageError('Missing module name.')
-        self.shell.extension_manager.load_extension(module_str)
+        if self.shell.extension_manager.load_extension(module_str) == 'already loaded':
+            print "The %s extension is already loaded. To reload it, use:" % module_str
+            print "  %reload_ext", module_str
 
     @line_magic
     def unload_ext(self, module_str):
-        """Unload an IPython extension by its module name."""
+        """Unload an IPython extension by its module name.
+        
+        Not all extensions can be unloaded, only those which define an
+        ``unload_ipython_extension`` function.
+        """
         if not module_str:
             raise UsageError('Missing module name.')
-        self.shell.extension_manager.unload_extension(module_str)
+        
+        res = self.shell.extension_manager.unload_extension(module_str)
+        
+        if res == 'no unload function':
+            print "The %s extension doesn't define how to unload it." % module_str
+        elif res == "not loaded":
+            print "The %s extension is not loaded." % module_str
 
     @line_magic
     def reload_ext(self, module_str):