Extensions no longer responsible for checking if they are already loaded

IPython/extensions/autoreload.py

@@ -1,522 +1,521 b''
 """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``
 
     Reload all modules (except those excluded by ``%aimport``)
     automatically now.
 
 ``%autoreload 0``
 
     Disable automatic reloading.
 
 ``%autoreload 1``
 
     Reload all modules imported with ``%aimport`` every time before
     executing the Python code typed.
 
 ``%autoreload 2``
 
     Reload all modules (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.
 
 ``%aimport foo``
 
     Import module 'foo' and mark it 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.
 """
 from __future__ import print_function
 
 skip_doctest = True
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2000 Thomas Heller
 #  Copyright (C) 2008 Pauli Virtanen <[e-mail]>
 #  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 imp
 import os
 import sys
 import traceback
 import types
 import weakref
 
 try:
     # Reload is not defined by default in Python3.
     reload
 except NameError:
     from imp import reload
 
 from IPython.utils import pyfile
 from IPython.utils.py3compat import PY3
 
 #------------------------------------------------------------------------------
 # Autoreload functionality
 #------------------------------------------------------------------------------
 
 def _get_compiled_ext():
     """Official way to get the extension of compiled files (.pyc or .pyo)"""
     for ext, mode, typ in imp.get_suffixes():
         if typ == imp.PY_COMPILED:
             return ext
 
 
 PY_COMPILED_EXT = _get_compiled_ext()
 
 
 class ModuleReloader(object):
     enabled = False
     """Whether this reloader is enabled"""
 
     failed = {}
     """Modules that failed to reload: {module: mtime-on-failed-reload, ...}"""
 
     modules = {}
     """Modules specially marked as autoreloadable."""
 
     skip_modules = {}
     """Modules specially marked as not autoreloadable."""
 
     check_all = True
     """Autoreload all modules, not just those listed in 'modules'"""
 
     old_objects = {}
     """(module-name, name) -> weakref, for replacing old code objects"""
 
     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_name)
         top_name = module_name.split('.')[0]
         top_module = sys.modules[top_name]
         return top_module, top_name
 
     def check(self, check_all=False):
         """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 = sys.modules.keys()
         else:
             modules = self.modules.keys()
 
         for modname in modules:
             m = sys.modules.get(modname, None)
 
             if modname in self.skip_modules:
                 continue
 
             if not hasattr(m, '__file__'):
                 continue
 
             if m.__name__ == '__main__':
                 # we cannot reload(__main__)
                 continue
 
             filename = m.__file__
             path, ext = os.path.splitext(filename)
 
             if ext.lower() == '.py':
                 ext = PY_COMPILED_EXT
                 pyc_filename = pyfile.cache_from_source(filename)
                 py_filename = filename
             else:
                 pyc_filename = filename
                 try:
                     py_filename = pyfile.source_from_cache(filename)
                 except ValueError:
                     continue
 
             try:
                 pymtime = os.stat(py_filename).st_mtime
                 if pymtime <= os.stat(pyc_filename).st_mtime:
                     continue
                 if self.failed.get(py_filename, None) == pymtime:
                     continue
             except OSError:
                 continue
 
             try:
                 superreload(m, reload, self.old_objects)
                 if py_filename in self.failed:
                     del self.failed[py_filename]
             except:
                 print("[autoreload of %s failed: %s]" % (
                         modname, traceback.format_exc(1)), file=sys.stderr)
                 self.failed[py_filename] = pymtime
 
 #------------------------------------------------------------------------------
 # superreload
 #------------------------------------------------------------------------------
 
 if PY3:
     func_attrs = ['__code__', '__defaults__', '__doc__',
                   '__closure__', '__globals__', '__dict__']
 else:
     func_attrs = ['func_code', 'func_defaults', 'func_doc',
                   'func_closure', 'func_globals', 'func_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_class(old, new):
     """Replace stuff in the __dict__ of a class, and upgrade
     method code objects"""
     for key in old.__dict__.keys():
         old_obj = getattr(old, key)
 
         try:
             new_obj = getattr(new, key)
         except AttributeError:
             # obsolete attribute: remove it
             try:
                 delattr(old, key)
             except (AttributeError, TypeError):
                 pass
             continue
 
         if update_generic(old_obj, new_obj): continue
 
         try:
             setattr(old, key, getattr(new, key))
         except (AttributeError, TypeError):
             pass # skip non-writable attributes
 
 
 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),
 ]
 
 
 if PY3:
     UPDATE_RULES.extend([(lambda a, b: isinstance2(a, b, types.MethodType),
                           lambda a, b: update_function(a.__func__, b.__func__)),
                         ])
 else:
     UPDATE_RULES.extend([(lambda a, b: isinstance2(a, b, types.ClassType),
                           update_class),
                          (lambda a, b: isinstance2(a, b, types.MethodType),
                           lambda a, b: update_function(a.im_func, b.im_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(object):
     def __init__(self, obj):
         self.obj = obj
     def __call__(self):
         return self.obj
 
 
 def superreload(module, reload=reload, old_objects={}):
     """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
 
     """
 
     # collect old objects in the module
     for name, obj in module.__dict__.items():
         if not hasattr(obj, '__module__') or obj.__module__ != module.__name__:
             continue
         key = (module.__name__, name)
         try:
             old_objects.setdefault(key, []).append(weakref.ref(obj))
         except TypeError:
             # weakref doesn't work for all types;
             # create strong references for 'important' cases
             if not PY3 and isinstance(obj, types.ClassType):
                 old_objects.setdefault(key, []).append(StrongRef(obj))
 
     # 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 module.__dict__.items():
         key = (module.__name__, name)
         if key not in old_objects: continue
 
         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
 #------------------------------------------------------------------------------
 
 from IPython.core.hooks import TryNext
 from IPython.core.magic import Magics, magics_class, line_magic
 
 @magics_class
 class AutoreloadMagics(Magics):
     def __init__(self, *a, **kw):
         super(AutoreloadMagics, self).__init__(*a, **kw)
         self._reloader = ModuleReloader()
         self._reloader.check_all = False
 
     @line_magic
     def autoreload(self, parameter_s=''):
         r"""%autoreload => Reload modules automatically
 
         %autoreload
         Reload all modules (except those excluded by %aimport) automatically
         now.
 
         %autoreload 0
         Disable automatic reloading.
 
         %autoreload 1
         Reload all modules imported with %aimport every time before executing
         the Python code typed.
 
         %autoreload 2
         Reload all modules (except those excluded by %aimport) every time
         before executing the Python code typed.
 
         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.
 
         """
         if parameter_s == '':
             self._reloader.check(True)
         elif parameter_s == '0':
             self._reloader.enabled = False
         elif parameter_s == '1':
             self._reloader.check_all = False
             self._reloader.enabled = True
         elif parameter_s == '2':
             self._reloader.check_all = True
             self._reloader.enabled = True
 
     @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 1
 
         %aimport -foo
         Mark module 'foo' to not be autoreloaded for %autoreload 1
         """
         modname = parameter_s
         if not modname:
             to_reload = self._reloader.modules.keys()
             to_reload.sort()
             to_skip = self._reloader.skip_modules.keys()
             to_skip.sort()
             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))
         elif modname.startswith('-'):
             modname = modname[1:]
             self._reloader.mark_module_skipped(modname)
         else:
             top_module, top_name = self._reloader.aimport_module(modname)
 
             # Inject module to user namespace
             self.shell.push({top_name: top_module})
 
     def pre_run_code_hook(self, ip):
         if not self._reloader.enabled:
             raise TryNext
         try:
             self._reloader.check()
         except:
             pass
 
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    if 'autoreload' not in ip.extension_manager.loaded:
-        auto_reload = AutoreloadMagics(ip)
-        ip.register_magics(auto_reload)
-        ip.set_hook('pre_run_code_hook', auto_reload.pre_run_code_hook)
+    auto_reload = AutoreloadMagics(ip)
+    ip.register_magics(auto_reload)
+    ip.set_hook('pre_run_code_hook', auto_reload.pre_run_code_hook)

IPython/extensions/cythonmagic.py

@@ -1,280 +1,279 b''
 # -*- coding: utf-8 -*-
 """
 Cython related magics.
 
 Author:
 * Brian Granger
 
 Parts of this code were taken from Cython.inline.
 """
 #-----------------------------------------------------------------------------
 # Copyright (C) 2010-2011, IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function
 
 import imp
 import io
 import os
 import re
 import sys
 import time
 
 try:
     import hashlib
 except ImportError:
     import md5 as hashlib
 
 from distutils.core import Distribution, Extension
 from distutils.command.build_ext import build_ext
 
 from IPython.core import display
 from IPython.core import magic_arguments
 from IPython.core.magic import Magics, magics_class, cell_magic
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import py3compat
 
 import Cython
 from Cython.Compiler.Errors import CompileError
 from Cython.Build.Dependencies import cythonize
 
 
 @magics_class
 class CythonMagics(Magics):
 
     def __init__(self, shell):
         super(CythonMagics,self).__init__(shell)
         self._reloads = {}
         self._code_cache = {}
 
     def _import_all(self, module):
         for k,v in module.__dict__.items():
             if not k.startswith('__'):
                 self.shell.push({k:v})
 
     @cell_magic
     def cython_inline(self, line, cell):
         """Compile and run a Cython code cell using Cython.inline.
 
         This magic simply passes the body of the cell to Cython.inline
         and returns the result. If the variables `a` and `b` are defined
         in the user's namespace, here is a simple example that returns
         their sum::
 
             %%cython_inline
             return a+b
 
         For most purposes, we recommend the usage of the `%%cython` magic.
         """
         locs = self.shell.user_global_ns
         globs = self.shell.user_ns
         return Cython.inline(cell, locals=locs, globals=globs)
 
     @cell_magic
     def cython_pyximport(self, line, cell):
         """Compile and import a Cython code cell using pyximport.
 
         The contents of the cell are written to a `.pyx` file in the current
         working directory, which is then imported using `pyximport`. This
         magic requires a module name to be passed::
 
             %%cython_pyximport modulename
             def f(x):
                 return 2.0*x
 
         The compiled module is then imported and all of its symbols are
         injected into the user's namespace. For most purposes, we recommend
         the usage of the `%%cython` magic.
         """
         module_name = line.strip()
         if not module_name:
             raise ValueError('module name must be given')
         fname = module_name + '.pyx'
         with io.open(fname, 'w', encoding='utf-8') as f:
             f.write(cell)
         if 'pyximport' not in sys.modules:
             import pyximport
             pyximport.install(reload_support=True)
         if module_name in self._reloads:
             module = self._reloads[module_name]
             reload(module)
         else:
             __import__(module_name)
             module = sys.modules[module_name]
             self._reloads[module_name] = module
         self._import_all(module)
 
     @magic_arguments.magic_arguments()
     @magic_arguments.argument(
         '-c', '--compile-args', action='append', default=[],
         help="Extra flags to pass to compiler via the `extra_compile_args` "
              "Extension flag (can be specified  multiple times)."
     )
     @magic_arguments.argument(
         '-la', '--link-args', action='append', default=[],
         help="Extra flags to pass to linker via the `extra_link_args` "
              "Extension flag (can be specified  multiple times)."
     )
     @magic_arguments.argument(
         '-l', '--lib', action='append', default=[],
         help="Add a library to link the extension against (can be specified "
              "multiple times)."
     )
     @magic_arguments.argument(
         '-L', dest='library_dirs', metavar='dir', action='append', default=[],
         help="Add a path to the list of libary directories (can be specified "
              "multiple times)."
     )
     @magic_arguments.argument(
         '-I', '--include', action='append', default=[],
         help="Add a path to the list of include directories (can be specified "
              "multiple times)."
     )
     @magic_arguments.argument(
         '-+', '--cplus', action='store_true', default=False,
         help="Output a C++ rather than C file."
     )
     @magic_arguments.argument(
         '-f', '--force', action='store_true', default=False,
         help="Force the compilation of a new module, even if the source has been "
              "previously compiled."
     )
     @magic_arguments.argument(
         '-a', '--annotate', action='store_true', default=False,
         help="Produce a colorized HTML version of the source."
     )
     @cell_magic
     def cython(self, line, cell):
         """Compile and import everything from a Cython code cell.
 
         The contents of the cell are written to a `.pyx` file in the
         directory `IPYTHONDIR/cython` using a filename with the hash of the
         code. This file is then cythonized and compiled. The resulting module
         is imported and all of its symbols are injected into the user's
         namespace. The usage is similar to that of `%%cython_pyximport` but
         you don't have to pass a module name::
 
         %%cython
         def f(x):
             return 2.0*x
         """
         args = magic_arguments.parse_argstring(self.cython, line)
         code = cell if cell.endswith('\n') else cell+'\n'
         lib_dir = os.path.join(self.shell.ipython_dir, 'cython')
         quiet = True
         key = code, sys.version_info, sys.executable, Cython.__version__
 
         if not os.path.exists(lib_dir):
             os.makedirs(lib_dir)
 
         if args.force:
             # Force a new module name by adding the current time to the
             # key which is hashed to determine the module name.
             key += time.time(),
 
         module_name = "_cython_magic_" + hashlib.md5(str(key).encode('utf-8')).hexdigest()
         module_path = os.path.join(lib_dir, module_name + self.so_ext)
 
         have_module = os.path.isfile(module_path)
         need_cythonize = not have_module
 
         if args.annotate:
             html_file = os.path.join(lib_dir, module_name + '.html')
             if not os.path.isfile(html_file):
                 need_cythonize = True
 
         if need_cythonize:
             c_include_dirs = args.include
             if 'numpy' in code:
                 import numpy
                 c_include_dirs.append(numpy.get_include())
             pyx_file = os.path.join(lib_dir, module_name + '.pyx')
             pyx_file = py3compat.cast_bytes_py2(pyx_file, encoding=sys.getfilesystemencoding())
             with io.open(pyx_file, 'w', encoding='utf-8') as f:
                 f.write(code)
             extension = Extension(
                 name = module_name,
                 sources = [pyx_file],
                 include_dirs = c_include_dirs,
                 library_dirs = args.library_dirs,
                 extra_compile_args = args.compile_args,
                 extra_link_args = args.link_args,
                 libraries = args.lib,
                 language = 'c++' if args.cplus else 'c',
             )
             build_extension = self._get_build_extension()
             try:
                 opts = dict(
                     quiet=quiet,
                     annotate = args.annotate,
                     force = True,
                     )
                 build_extension.extensions = cythonize([extension], **opts)
             except CompileError:
                 return
 
         if not have_module:
             build_extension.build_temp = os.path.dirname(pyx_file)
             build_extension.build_lib  = lib_dir
             build_extension.run()
             self._code_cache[key] = module_name
 
         module = imp.load_dynamic(module_name, module_path)
         self._import_all(module)
 
         if args.annotate:
             try:
                 with io.open(html_file, encoding='utf-8') as f:
                     annotated_html = f.read()
             except IOError as e:
                 # File could not be opened. Most likely the user has a version
                 # of Cython before 0.15.1 (when `cythonize` learned the
                 # `force` keyword argument) and has already compiled this
                 # exact source without annotation.
                 print('Cython completed successfully but the annotated '
                       'source could not be read.', file=sys.stderr)
                 print(e, file=sys.stderr)
             else:
                 return display.HTML(self.clean_annotated_html(annotated_html))
 
     @property
     def so_ext(self):
         """The extension suffix for compiled modules."""
         try:
             return self._so_ext
         except AttributeError:
             self._so_ext = self._get_build_extension().get_ext_filename('')
             return self._so_ext
 
     def _get_build_extension(self):
         dist = Distribution()
         config_files = dist.find_config_files()
         try:
             config_files.remove('setup.cfg')
         except ValueError:
             pass
         dist.parse_config_files(config_files)
         build_extension = build_ext(dist)
         build_extension.finalize_options()
         return build_extension
 
     @staticmethod
     def clean_annotated_html(html):
         """Clean up the annotated HTML source.
 
         Strips the link to the generated C or C++ file, which we do not
         present to the user.
         """
         r = re.compile('<p>Raw output: <a href="(.*)">(.*)</a>')
         html = '\n'.join(l for l in html.splitlines() if not r.match(l))
         return html
 
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    if 'cythonmagic' not in ip.extension_manager.loaded:
-        ip.register_magics(CythonMagics)
+    ip.register_magics(CythonMagics)

IPython/extensions/octavemagic.py

@@ -1,368 +1,367 b''
 # -*- coding: utf-8 -*-
 """
 ===========
 octavemagic
 ===========
 
 Magics for interacting with Octave via oct2py.
 
 .. note::
 
   The ``oct2py`` module needs to be installed separately and
   can be obtained using ``easy_install`` or ``pip``.
 
 Usage
 =====
 
 ``%octave``
 
 {OCTAVE_DOC}
 
 ``%octave_push``
 
 {OCTAVE_PUSH_DOC}
 
 ``%octave_pull``
 
 {OCTAVE_PULL_DOC}
 
 """
 
 #-----------------------------------------------------------------------------
 #  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.
 #-----------------------------------------------------------------------------
 
 import tempfile
 from glob import glob
 from shutil import rmtree
 
 import numpy as np
 import oct2py
 from xml.dom import minidom
 
 from IPython.core.displaypub import publish_display_data
 from IPython.core.magic import (Magics, magics_class, line_magic,
                                 line_cell_magic, needs_local_scope)
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.core.magic_arguments import (
     argument, magic_arguments, parse_argstring
 )
 from IPython.utils.py3compat import unicode_to_str
 
 class OctaveMagicError(oct2py.Oct2PyError):
     pass
 
 _mimetypes = {'png' : 'image/png',
              'svg' : 'image/svg+xml',
              'jpg' : 'image/jpeg',
               'jpeg': 'image/jpeg'}
 
 @magics_class
 class OctaveMagics(Magics):
     """A set of magics useful for interactive work with Octave via oct2py.
     """
     def __init__(self, shell):
         """
         Parameters
         ----------
         shell : IPython shell
 
         """
         super(OctaveMagics, self).__init__(shell)
         self._oct = oct2py.Oct2Py()
         self._plot_format = 'png'
 
         # Allow publish_display_data to be overridden for
         # testing purposes.
         self._publish_display_data = publish_display_data
 
 
     def _fix_gnuplot_svg_size(self, image, size=None):
         """
         GnuPlot SVGs do not have height/width attributes.  Set
         these to be the same as the viewBox, so that the browser
         scales the image correctly.
 
         Parameters
         ----------
         image : str
             SVG data.
         size : tuple of int
             Image width, height.
 
         """
         (svg,) = minidom.parseString(image).getElementsByTagName('svg')
         viewbox = svg.getAttribute('viewBox').split(' ')
 
         if size is not None:
             width, height = size
         else:
             width, height = viewbox[2:]
 
         svg.setAttribute('width', '%dpx' % width)
         svg.setAttribute('height', '%dpx' % height)
         return svg.toxml()
 
 
     @skip_doctest
     @line_magic
     def octave_push(self, line):
         '''
         Line-level magic that pushes a variable to Octave.
 
         `line` should be made up of whitespace separated variable names in the
         IPython namespace::
 
             In [7]: import numpy as np
 
             In [8]: X = np.arange(5)
 
             In [9]: X.mean()
             Out[9]: 2.0
 
             In [10]: %octave_push X
 
             In [11]: %octave mean(X)
             Out[11]: 2.0
 
         '''
         inputs = line.split(' ')
         for input in inputs:
             input = unicode_to_str(input)
             self._oct.put(input, self.shell.user_ns[input])
 
 
     @skip_doctest
     @line_magic
     def octave_pull(self, line):
         '''
         Line-level magic that pulls a variable from Octave.
 
             In [18]: _ = %octave x = [1 2; 3 4]; y = 'hello'
 
             In [19]: %octave_pull x y
 
             In [20]: x
             Out[20]:
             array([[ 1.,  2.],
                    [ 3.,  4.]])
 
             In [21]: y
             Out[21]: 'hello'
 
         '''
         outputs = line.split(' ')
         for output in outputs:
             output = unicode_to_str(output)
             self.shell.push({output: self._oct.get(output)})
 
 
     @skip_doctest
     @magic_arguments()
     @argument(
         '-i', '--input', action='append',
         help='Names of input variables to be pushed to Octave. Multiple names '
              'can be passed, separated by commas with no whitespace.'
         )
     @argument(
         '-o', '--output', action='append',
         help='Names of variables to be pulled from Octave after executing cell '
              'body. Multiple names can be passed, separated by commas with no '
              'whitespace.'
         )
     @argument(
         '-s', '--size', action='store',
         help='Pixel size of plots, "width,height". Default is "-s 400,250".'
         )
     @argument(
         '-f', '--format', action='store',
         help='Plot format (png, svg or jpg).'
         )
 
     @needs_local_scope
     @argument(
         'code',
         nargs='*',
         )
     @line_cell_magic
     def octave(self, line, cell=None, local_ns=None):
         '''
         Execute code in Octave, and pull some of the results back into the
         Python namespace.
 
             In [9]: %octave X = [1 2; 3 4]; mean(X)
             Out[9]: array([[ 2., 3.]])
 
         As a cell, this will run a block of Octave code, without returning any
         value::
 
             In [10]: %%octave
                ....: p = [-2, -1, 0, 1, 2]
                ....: polyout(p, 'x')
 
             -2*x^4 - 1*x^3 + 0*x^2 + 1*x^1 + 2
 
         In the notebook, plots are published as the output of the cell, e.g.
 
         %octave plot([1 2 3], [4 5 6])
 
         will create a line plot.
 
         Objects can be passed back and forth between Octave and IPython via the
         -i and -o flags in line::
 
             In [14]: Z = np.array([1, 4, 5, 10])
 
             In [15]: %octave -i Z mean(Z)
             Out[15]: array([ 5.])
 
 
             In [16]: %octave -o W W = Z * mean(Z)
             Out[16]: array([  5.,  20.,  25.,  50.])
 
             In [17]: W
             Out[17]: array([  5.,  20.,  25.,  50.])
 
         The size and format of output plots can be specified::
 
             In [18]: %%octave -s 600,800 -f svg
                 ...: plot([1, 2, 3]);
 
         '''
         args = parse_argstring(self.octave, line)
 
         # arguments 'code' in line are prepended to the cell lines
         if cell is None:
             code = ''
             return_output = True
         else:
             code = cell
             return_output = False
 
         code = ' '.join(args.code) + code
 
         # if there is no local namespace then default to an empty dict
         if local_ns is None:
             local_ns = {}
 
         if args.input:
             for input in ','.join(args.input).split(','):
                 input = unicode_to_str(input)
                 try:
                     val = local_ns[input]
                 except KeyError:
                     val = self.shell.user_ns[input]
                 self._oct.put(input, val)
 
         # generate plots in a temporary directory
         plot_dir = tempfile.mkdtemp()
         if args.size is not None:
             size = args.size
         else:
             size = '400,240'
 
         if args.format is not None:
             plot_format = args.format
         else:
             plot_format = 'png'
 
         pre_call = '''
         global __ipy_figures = [];
         page_screen_output(0);
 
         function fig_create(src, event)
           global __ipy_figures;
           __ipy_figures(size(__ipy_figures) + 1) = src;
           set(src, "visible", "off");
         end
 
         set(0, 'DefaultFigureCreateFcn', @fig_create);
 
         close all;
         clear ans;
 
         # ___<end_pre_call>___ #
         '''
 
         post_call = '''
         # ___<start_post_call>___ #
 
         # Save output of the last execution
         if exist("ans") == 1
           _ = ans;
         else
           _ = nan;
         end
 
         for f = __ipy_figures
           outfile = sprintf('%(plot_dir)s/__ipy_oct_fig_%%03d.png', f);
           try
             print(f, outfile, '-d%(plot_format)s', '-tight', '-S%(size)s');
           end
         end
 
         ''' % locals()
 
         code = ' '.join((pre_call, code, post_call))
         try:
             text_output = self._oct.run(code, verbose=False)
         except (oct2py.Oct2PyError) as exception:
             msg = exception.message
             msg = msg.split('# ___<end_pre_call>___ #')[1]
             msg = msg.split('# ___<start_post_call>___ #')[0]
             raise OctaveMagicError('Octave could not complete execution.  '
                                    'Traceback (currently broken in oct2py): %s'
                                    % msg)
 
         key = 'OctaveMagic.Octave'
         display_data = []
 
         # Publish text output
         if text_output:
             display_data.append((key, {'text/plain': text_output}))
 
         # Publish images
         images = [open(imgfile, 'rb').read() for imgfile in \
                   glob("%s/*" % plot_dir)]
         rmtree(plot_dir)
 
         plot_mime_type = _mimetypes.get(plot_format, 'image/png')
         width, height = [int(s) for s in size.split(',')]
         for image in images:
             if plot_format == 'svg':
                 image = self._fix_gnuplot_svg_size(image, size=(width, height))
             display_data.append((key, {plot_mime_type: image}))
 
         if args.output:
             for output in ','.join(args.output).split(','):
                 output = unicode_to_str(output)
                 self.shell.push({output: self._oct.get(output)})
 
         for source, data in display_data:
             self._publish_display_data(source, data)
 
         if return_output:
             ans = self._oct.get('_')
 
             # Unfortunately, Octave doesn't have a "None" object,
             # so we can't return any NaN outputs
             if np.isscalar(ans) and np.isnan(ans):
                 ans = None
 
             return ans
 
 
 __doc__ = __doc__.format(
     OCTAVE_DOC = ' '*8 + OctaveMagics.octave.__doc__,
     OCTAVE_PUSH_DOC = ' '*8 + OctaveMagics.octave_push.__doc__,
     OCTAVE_PULL_DOC = ' '*8 + OctaveMagics.octave_pull.__doc__
     )
 
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    if 'octavemagic' not in ip.extension_manager.loaded:
-        ip.register_magics(OctaveMagics)
+    ip.register_magics(OctaveMagics)

IPython/extensions/rmagic.py

@@ -1,594 +1,593 b''
 # -*- coding: utf-8 -*-
 """
 ======
 Rmagic
 ======
 
 Magic command interface for interactive work with R via rpy2
 
 Usage
 =====
 
 ``%R``
 
 {R_DOC}
 
 ``%Rpush``
 
 {RPUSH_DOC}
 
 ``%Rpull``
 
 {RPULL_DOC}
 
 ``%Rget``
 
 {RGET_DOC}
 
 """
 
 #-----------------------------------------------------------------------------
 #  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.
 #-----------------------------------------------------------------------------
 
 import sys
 import tempfile
 from glob import glob
 from shutil import rmtree
 from getopt import getopt
 
 # numpy and rpy2 imports
 
 import numpy as np
 
 import rpy2.rinterface as ri
 import rpy2.robjects as ro
 from rpy2.robjects.numpy2ri import numpy2ri
 ro.conversion.py2ri = numpy2ri
 
 # IPython imports
 
 from IPython.core.displaypub import publish_display_data
 from IPython.core.magic import (Magics, magics_class, cell_magic, line_magic,
                                 line_cell_magic, needs_local_scope)
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.core.magic_arguments import (
     argument, magic_arguments, parse_argstring
 )
 from IPython.utils.py3compat import str_to_unicode, unicode_to_str, PY3
 
 class RInterpreterError(ri.RRuntimeError):
     """An error when running R code in a %%R magic cell."""
     def __init__(self, line, err, stdout):
         self.line = line
         self.err = err.rstrip()
         self.stdout = stdout.rstrip()
     
     def __unicode__(self):
         s = 'Failed to parse and evaluate line %r.\nR error message: %r' % \
                 (self.line, self.err)
         if self.stdout and (self.stdout != self.err):
             s += '\nR stdout:\n' + self.stdout
         return s
     
     if PY3:
         __str__ = __unicode__
     else:
         def __str__(self):
             return unicode_to_str(unicode(self), 'utf-8')
 
 def Rconverter(Robj, dataframe=False):
     """
     Convert an object in R's namespace to one suitable
     for ipython's namespace.
 
     For a data.frame, it tries to return a structured array.
     It first checks for colnames, then names.
     If all are NULL, it returns np.asarray(Robj), else
     it tries to construct a recarray
 
     Parameters
     ----------
 
     Robj: an R object returned from rpy2
     """
     is_data_frame = ro.r('is.data.frame')
     colnames = ro.r('colnames')
     rownames = ro.r('rownames') # with pandas, these could be used for the index
     names = ro.r('names')
 
     if dataframe:
         as_data_frame = ro.r('as.data.frame')
         cols = colnames(Robj)
         _names = names(Robj)
         if cols != ri.NULL:
             Robj = as_data_frame(Robj)
             names = tuple(np.array(cols))
         elif _names != ri.NULL:
             names = tuple(np.array(_names))
         else: # failed to find names
             return np.asarray(Robj)
         Robj = np.rec.fromarrays(Robj, names = names)
     return np.asarray(Robj)
 
 @magics_class
 class RMagics(Magics):
     """A set of magics useful for interactive work with R via rpy2.
     """
 
     def __init__(self, shell, Rconverter=Rconverter,
                  pyconverter=np.asarray,
                  cache_display_data=False):
         """
         Parameters
         ----------
 
         shell : IPython shell
 
         pyconverter : callable
             To be called on values in ipython namespace before 
             assigning to variables in rpy2.
 
         cache_display_data : bool
             If True, the published results of the final call to R are 
             cached in the variable 'display_cache'.
 
         """
         super(RMagics, self).__init__(shell)
         self.cache_display_data = cache_display_data
 
         self.r = ro.R()
 
         self.Rstdout_cache = []
         self.pyconverter = pyconverter
         self.Rconverter = Rconverter
 
     def eval(self, line):
         '''
         Parse and evaluate a line with rpy2.
         Returns the output to R's stdout() connection
         and the value of eval(parse(line)).
         '''
         old_writeconsole = ri.get_writeconsole()
         ri.set_writeconsole(self.write_console)
         try:
             value = ri.baseenv['eval'](ri.parse(line))
         except (ri.RRuntimeError, ValueError) as exception:
             warning_or_other_msg = self.flush() # otherwise next return seems to have copy of error
             raise RInterpreterError(line, str_to_unicode(str(exception)), warning_or_other_msg)
         text_output = self.flush()
         ri.set_writeconsole(old_writeconsole)
         return text_output, value
 
     def write_console(self, output):
         '''
         A hook to capture R's stdout in a cache.
         '''
         self.Rstdout_cache.append(output)
 
     def flush(self):
         '''
         Flush R's stdout cache to a string, returning the string.
         '''
         value = ''.join([str_to_unicode(s, 'utf-8') for s in self.Rstdout_cache])
         self.Rstdout_cache = []
         return value
 
     @skip_doctest
     @line_magic
     def Rpush(self, line):
         '''
         A line-level magic for R that pushes
         variables from python to rpy2. The line should be made up
         of whitespace separated variable names in the IPython
         namespace::
 
             In [7]: import numpy as np
 
             In [8]: X = np.array([4.5,6.3,7.9])
 
             In [9]: X.mean()
             Out[9]: 6.2333333333333343
 
             In [10]: %Rpush X
 
             In [11]: %R mean(X)
             Out[11]: array([ 6.23333333])
 
         '''
 
         inputs = line.split(' ')
         for input in inputs:
             self.r.assign(input, self.pyconverter(self.shell.user_ns[input]))
 
     @skip_doctest
     @magic_arguments()
     @argument(
         '-d', '--as_dataframe', action='store_true',
         default=False,
         help='Convert objects to data.frames before returning to ipython.'
         )
     @argument(
         'outputs',
         nargs='*',
         )
     @line_magic
     def Rpull(self, line):
         '''
         A line-level magic for R that pulls
         variables from python to rpy2::
 
             In [18]: _ = %R x = c(3,4,6.7); y = c(4,6,7); z = c('a',3,4)
 
             In [19]: %Rpull x  y z
 
             In [20]: x
             Out[20]: array([ 3. ,  4. ,  6.7])
 
             In [21]: y
             Out[21]: array([ 4.,  6.,  7.])
 
             In [22]: z
             Out[22]:
             array(['a', '3', '4'],
                   dtype='|S1')
 
 
         If --as_dataframe, then each object is returned as a structured array
         after first passed through "as.data.frame" in R before
         being calling self.Rconverter. 
         This is useful when a structured array is desired as output, or
         when the object in R has mixed data types. 
         See the %%R docstring for more examples.
 
         Notes
         -----
 
         Beware that R names can have '.' so this is not fool proof.
         To avoid this, don't name your R objects with '.'s...
 
         '''
         args = parse_argstring(self.Rpull, line)
         outputs = args.outputs
         for output in outputs:
             self.shell.push({output:self.Rconverter(self.r(output),dataframe=args.as_dataframe)})
 
     @skip_doctest
     @magic_arguments()
     @argument(
         '-d', '--as_dataframe', action='store_true',
         default=False,
         help='Convert objects to data.frames before returning to ipython.'
         )
     @argument(
         'output',
         nargs=1,
         type=str,
         )
     @line_magic
     def Rget(self, line):
         '''
         Return an object from rpy2, possibly as a structured array (if possible).
         Similar to Rpull except only one argument is accepted and the value is 
         returned rather than pushed to self.shell.user_ns::
 
             In [3]: dtype=[('x', '<i4'), ('y', '<f8'), ('z', '|S1')]
 
             In [4]: datapy = np.array([(1, 2.9, 'a'), (2, 3.5, 'b'), (3, 2.1, 'c'), (4, 5, 'e')], dtype=dtype)
 
             In [5]: %R -i datapy
 
             In [6]: %Rget datapy
             Out[6]: 
             array([['1', '2', '3', '4'],
                    ['2', '3', '2', '5'],
                    ['a', 'b', 'c', 'e']], 
                   dtype='|S1')
 
             In [7]: %Rget -d datapy
             Out[7]: 
             array([(1, 2.9, 'a'), (2, 3.5, 'b'), (3, 2.1, 'c'), (4, 5.0, 'e')], 
                   dtype=[('x', '<i4'), ('y', '<f8'), ('z', '|S1')])
 
         '''
         args = parse_argstring(self.Rget, line)
         output = args.output
         return self.Rconverter(self.r(output[0]),dataframe=args.as_dataframe)
 
 
     @skip_doctest
     @magic_arguments()
     @argument(
         '-i', '--input', action='append',
         help='Names of input variable from shell.user_ns to be assigned to R variables of the same names after calling self.pyconverter. Multiple names can be passed separated only by commas with no whitespace.'
         )
     @argument(
         '-o', '--output', action='append',
         help='Names of variables to be pushed from rpy2 to shell.user_ns after executing cell body and applying self.Rconverter. Multiple names can be passed separated only by commas with no whitespace.'
         )
     @argument(
         '-w', '--width', type=int,
         help='Width of png plotting device sent as an argument to *png* in R.'
         )
     @argument(
         '-h', '--height', type=int,
         help='Height of png plotting device sent as an argument to *png* in R.'
         )
 
     @argument(
         '-d', '--dataframe', action='append',
         help='Convert these objects to data.frames and return as structured arrays.'
         )
     @argument(
         '-u', '--units', type=int,
         help='Units of png plotting device sent as an argument to *png* in R. One of ["px", "in", "cm", "mm"].'
         )
     @argument(
         '-p', '--pointsize', type=int,
         help='Pointsize of png plotting device sent as an argument to *png* in R.'
         )
     @argument(
         '-b', '--bg',
         help='Background of png plotting device sent as an argument to *png* in R.'
         )
     @argument(
         '-n', '--noreturn',
         help='Force the magic to not return anything.',
         action='store_true',
         default=False
         )
     @argument(
         'code',
         nargs='*',
         )
     @needs_local_scope
     @line_cell_magic
     def R(self, line, cell=None, local_ns=None):
         '''
         Execute code in R, and pull some of the results back into the Python namespace.
 
         In line mode, this will evaluate an expression and convert the returned value to a Python object.
         The return value is determined by rpy2's behaviour of returning the result of evaluating the
         final line. 
 
         Multiple R lines can be executed by joining them with semicolons::
 
             In [9]: %R X=c(1,4,5,7); sd(X); mean(X)
             Out[9]: array([ 4.25])
 
         As a cell, this will run a block of R code, without bringing anything back by default::
 
             In [10]: %%R
                ....: Y = c(2,4,3,9)
                ....: print(summary(lm(Y~X)))
                ....:
 
             Call:
             lm(formula = Y ~ X)
 
             Residuals:
                 1     2     3     4
              0.88 -0.24 -2.28  1.64
 
             Coefficients:
                         Estimate Std. Error t value Pr(>|t|)
             (Intercept)   0.0800     2.3000   0.035    0.975
             X             1.0400     0.4822   2.157    0.164
 
             Residual standard error: 2.088 on 2 degrees of freedom
             Multiple R-squared: 0.6993,Adjusted R-squared: 0.549
             F-statistic: 4.651 on 1 and 2 DF,  p-value: 0.1638
 
         In the notebook, plots are published as the output of the cell.
 
         %R plot(X, Y)
 
         will create a scatter plot of X bs Y.
 
         If cell is not None and line has some R code, it is prepended to
         the R code in cell.
 
         Objects can be passed back and forth between rpy2 and python via the -i -o flags in line::
 
             In [14]: Z = np.array([1,4,5,10])
 
             In [15]: %R -i Z mean(Z)
             Out[15]: array([ 5.])
 
 
             In [16]: %R -o W W=Z*mean(Z)
             Out[16]: array([  5.,  20.,  25.,  50.])
 
             In [17]: W
             Out[17]: array([  5.,  20.,  25.,  50.])
 
         The return value is determined by these rules:
 
         * If the cell is not None, the magic returns None.
 
         * If the cell evaluates as False, the resulting value is returned
         unless the final line prints something to the console, in
         which case None is returned.
 
         * If the final line results in a NULL value when evaluated
         by rpy2, then None is returned.
 
         * No attempt is made to convert the final value to a structured array.
         Use the --dataframe flag or %Rget to push / return a structured array.
 
         * If the -n flag is present, there is no return value.
 
         * A trailing ';' will also result in no return value as the last
         value in the line is an empty string.
 
         The --dataframe argument will attempt to return structured arrays. 
         This is useful for dataframes with
         mixed data types. Note also that for a data.frame, 
         if it is returned as an ndarray, it is transposed::
 
             In [18]: dtype=[('x', '<i4'), ('y', '<f8'), ('z', '|S1')]
 
             In [19]: datapy = np.array([(1, 2.9, 'a'), (2, 3.5, 'b'), (3, 2.1, 'c'), (4, 5, 'e')], dtype=dtype)
 
             In [20]: %%R -o datar
             datar = datapy
                ....: 
 
             In [21]: datar
             Out[21]: 
             array([['1', '2', '3', '4'],
                    ['2', '3', '2', '5'],
                    ['a', 'b', 'c', 'e']], 
                   dtype='|S1')
 
             In [22]: %%R -d datar
             datar = datapy
                ....: 
 
             In [23]: datar
             Out[23]: 
             array([(1, 2.9, 'a'), (2, 3.5, 'b'), (3, 2.1, 'c'), (4, 5.0, 'e')], 
                   dtype=[('x', '<i4'), ('y', '<f8'), ('z', '|S1')])
 
         The --dataframe argument first tries colnames, then names.
         If both are NULL, it returns an ndarray (i.e. unstructured)::
 
             In [1]: %R mydata=c(4,6,8.3); NULL
 
             In [2]: %R -d mydata
 
             In [3]: mydata
             Out[3]: array([ 4. ,  6. ,  8.3])
 
             In [4]: %R names(mydata) = c('a','b','c'); NULL
 
             In [5]: %R -d mydata
 
             In [6]: mydata
             Out[6]: 
             array((4.0, 6.0, 8.3), 
                   dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])
 
             In [7]: %R -o mydata
 
             In [8]: mydata
             Out[8]: array([ 4. ,  6. ,  8.3])
 
         '''
 
         args = parse_argstring(self.R, line)
 
         # arguments 'code' in line are prepended to
         # the cell lines
 
         if cell is None:
             code = ''
             return_output = True
             line_mode = True
         else:
             code = cell
             return_output = False
             line_mode = False
 
         code = ' '.join(args.code) + code
 
         # if there is no local namespace then default to an empty dict
         if local_ns is None:
             local_ns = {}
 
         if args.input:
             for input in ','.join(args.input).split(','):
                 try:
                     val = local_ns[input]
                 except KeyError:
                     val = self.shell.user_ns[input]
                 self.r.assign(input, self.pyconverter(val))
 
         png_argdict = dict([(n, getattr(args, n)) for n in ['units', 'height', 'width', 'bg', 'pointsize']])
         png_args = ','.join(['%s=%s' % (o,v) for o, v in png_argdict.items() if v is not None])
         # execute the R code in a temporary directory
 
         tmpd = tempfile.mkdtemp()
         self.r('png("%s/Rplots%%03d.png",%s)' % (tmpd, png_args))
 
         text_output = ''
         if line_mode:
             for line in code.split(';'):
                 text_result, result = self.eval(line)
                 text_output += text_result
             if text_result:
                 # the last line printed something to the console so we won't return it
                 return_output = False
         else:
             text_result, result = self.eval(code)
             text_output += text_result
 
         self.r('dev.off()')
 
         # read out all the saved .png files
 
         images = [open(imgfile, 'rb').read() for imgfile in glob("%s/Rplots*png" % tmpd)]
 
         # now publish the images
         # mimicking IPython/zmq/pylab/backend_inline.py
         fmt = 'png'
         mimetypes = { 'png' : 'image/png', 'svg' : 'image/svg+xml' }
         mime = mimetypes[fmt]
 
         # publish the printed R objects, if any
 
         display_data = []
         if text_output:
             display_data.append(('RMagic.R', {'text/plain':text_output}))
 
         # flush text streams before sending figures, helps a little with output
         for image in images:
             # synchronization in the console (though it's a bandaid, not a real sln)
             sys.stdout.flush(); sys.stderr.flush()
             display_data.append(('RMagic.R', {mime: image}))
 
         # kill the temporary directory
         rmtree(tmpd)
 
         # try to turn every output into a numpy array
         # this means that output are assumed to be castable
         # as numpy arrays
 
         if args.output:
             for output in ','.join(args.output).split(','):
                 self.shell.push({output:self.Rconverter(self.r(output), dataframe=False)})
 
         if args.dataframe:
             for output in ','.join(args.dataframe).split(','):
                 self.shell.push({output:self.Rconverter(self.r(output), dataframe=True)})
 
         for tag, disp_d in display_data:
             publish_display_data(tag, disp_d)
 
         # this will keep a reference to the display_data
         # which might be useful to other objects who happen to use
         # this method
 
         if self.cache_display_data:
             self.display_cache = display_data
 
         # if in line mode and return_output, return the result as an ndarray
         if return_output and not args.noreturn:
             if result != ri.NULL:
                 return self.Rconverter(result, dataframe=False)
 
 __doc__ = __doc__.format(
                 R_DOC = ' '*8 + RMagics.R.__doc__,
                 RPUSH_DOC = ' '*8 + RMagics.Rpush.__doc__,
                 RPULL_DOC = ' '*8 + RMagics.Rpull.__doc__,
                 RGET_DOC = ' '*8 + RMagics.Rget.__doc__
 )
 
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    if 'rmagic' not in ip.extension_manager.loaded:
-        ip.register_magics(RMagics)
+    ip.register_magics(RMagics)

IPython/extensions/storemagic.py

@@ -1,215 +1,214 b''
 # -*- coding: utf-8 -*-
 """
 %store magic for lightweight persistence.
 
 Stores variables, aliases and macros in IPython's database.
 
 To automatically restore stored variables at startup, add this to your
 :file:`ipython_config.py` file::
 
   c.StoreMagic.autorestore = True
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012, The IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib
 import inspect, os, sys, textwrap
 
 # Our own
 from IPython.core.error import UsageError
 from IPython.core.fakemodule import FakeModule
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.testing.skipdoctest import skip_doctest
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
     
 def restore_aliases(ip):
     staliases = ip.db.get('stored_aliases', {})
     for k,v in staliases.items():
         #print "restore alias",k,v # dbg
         #self.alias_table[k] = v
         ip.alias_manager.define_alias(k,v)
 
 
 def refresh_variables(ip):
     db = ip.db
     for key in db.keys('autorestore/*'):
         # strip autorestore
         justkey = os.path.basename(key)
         try:
             obj = db[key]
         except KeyError:
             print "Unable to restore variable '%s', ignoring (use %%store -d to forget!)" % justkey
             print "The error was:", sys.exc_info()[0]
         else:
             #print "restored",justkey,"=",obj #dbg
             ip.user_ns[justkey] = obj
 
 
 def restore_dhist(ip):
     ip.user_ns['_dh'] = ip.db.get('dhist',[])
 
 
 def restore_data(ip):
     refresh_variables(ip)
     restore_aliases(ip)
     restore_dhist(ip)
 
 
 @magics_class
 class StoreMagics(Magics):
     """Lightweight persistence for python variables.
 
     Provides the %store magic."""
 
     @skip_doctest
     @line_magic
     def store(self, parameter_s=''):
         """Lightweight persistence for python variables.
 
         Example::
 
           In [1]: l = ['hello',10,'world']
           In [2]: %store l
           In [3]: exit
 
           (IPython session is closed and started again...)
 
           ville@badger:~$ ipython
           In [1]: l
           Out[1]: ['hello', 10, 'world']
 
         Usage:
 
         * ``%store``          - Show list of all variables and their current
                                 values
         * ``%store spam``     - Store the *current* value of the variable spam
                                 to disk
         * ``%store -d spam``  - Remove the variable and its value from storage
         * ``%store -z``       - Remove all variables from storage
         * ``%store -r``       - Refresh all variables from store (delete
                                 current vals)
         * ``%store foo >a.txt``  - Store value of foo to new file a.txt
         * ``%store foo >>a.txt`` - Append value of foo to file a.txt
 
         It should be noted that if you change the value of a variable, you
         need to %store it again if you want to persist the new value.
 
         Note also that the variables will need to be pickleable; most basic
         python types can be safely %store'd.
 
         Also aliases can be %store'd across sessions.
         """
 
         opts,argsl = self.parse_options(parameter_s,'drz',mode='string')
         args = argsl.split(None,1)
         ip = self.shell
         db = ip.db
         # delete
         if 'd' in opts:
             try:
                 todel = args[0]
             except IndexError:
                 raise UsageError('You must provide the variable to forget')
             else:
                 try:
                     del db['autorestore/' + todel]
                 except:
                     raise UsageError("Can't delete variable '%s'" % todel)
         # reset
         elif 'z' in opts:
             for k in db.keys('autorestore/*'):
                 del db[k]
 
         elif 'r' in opts:
             refresh_variables(ip)
 
 
         # run without arguments -> list variables & values
         elif not args:
             vars = db.keys('autorestore/*')
             vars.sort()
             if vars:
                 size = max(map(len, vars))
             else:
                 size = 0
 
             print 'Stored variables and their in-db values:'
             fmt = '%-'+str(size)+'s -> %s'
             get = db.get
             for var in vars:
                 justkey = os.path.basename(var)
                 # print 30 first characters from every var
                 print fmt % (justkey, repr(get(var, '<unavailable>'))[:50])
 
         # default action - store the variable
         else:
             # %store foo >file.txt or >>file.txt
             if len(args) > 1 and args[1].startswith('>'):
                 fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
                 if args[1].startswith('>>'):
                     fil = open(fnam, 'a')
                 else:
                     fil = open(fnam, 'w')
                 obj = ip.ev(args[0])
                 print "Writing '%s' (%s) to file '%s'." % (args[0],
                   obj.__class__.__name__, fnam)
 
 
                 if not isinstance (obj, basestring):
                     from pprint import pprint
                     pprint(obj, fil)
                 else:
                     fil.write(obj)
                     if not obj.endswith('\n'):
                         fil.write('\n')
 
                 fil.close()
                 return
 
             # %store foo
             try:
                 obj = ip.user_ns[args[0]]
             except KeyError:
                 # it might be an alias
                 # This needs to be refactored to use the new AliasManager stuff.
                 if args[0] in ip.alias_manager:
                     name = args[0]
                     nargs, cmd = ip.alias_manager.alias_table[ name ]
                     staliases = db.get('stored_aliases',{})
                     staliases[ name ] = cmd
                     db['stored_aliases'] = staliases
                     print "Alias stored: %s (%s)" % (name, cmd)
                     return
                 else:
                     raise UsageError("Unknown variable '%s'" % args[0])
 
             else:
                 if isinstance(inspect.getmodule(obj), FakeModule):
                     print textwrap.dedent("""\
                     Warning:%s is %s
                     Proper storage of interactively declared classes (or instances
                     of those classes) is not possible! Only instances
                     of classes in real modules on file system can be %%store'd.
                     """ % (args[0], obj) )
                     return
                 #pickled = pickle.dumps(obj)
                 db[ 'autorestore/' + args[0] ] = obj
                 print "Stored '%s' (%s)" % (args[0], obj.__class__.__name__)
 
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
-    if 'storemagic' not in ip.extension_manager.loaded:
-        ip.register_magics(StoreMagics)
+    ip.register_magics(StoreMagics)