Parallel magics (%result, %px, %autopx) are fixed.

* They are now a proper extension using Components and the extension
  API.
* The are loaded by the cluster profile.

IPython/extensions/parallelmagic.py

@@ -0,0 +1,205 b''
+#!/usr/bin/env python
+# encoding: utf-8
+
+"""Magic command interface for interactive parallel work."""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import new
+
+from IPython.core.component import Component
+from IPython.utils.traitlets import Bool, Any
+from IPython.utils.autoattr import auto_attr
+
+#-----------------------------------------------------------------------------
+# Definitions of magic functions for use with IPython
+#-----------------------------------------------------------------------------
+
+
+NO_ACTIVE_MULTIENGINE_CLIENT = """
+Use activate() on a MultiEngineClient object to activate it for magics.
+"""
+
+
+class ParalleMagicComponent(Component):
+    """A component to manage the %result, %px and %autopx magics."""
+
+    active_multiengine_client = Any()
+    verbose = Bool(False, config=True)
+
+    def __init__(self, parent, name=None, config=None):
+        super(ParalleMagicComponent, self).__init__(parent, name=name, config=config)
+        self._define_magics()
+        # A flag showing if autopx is activated or not
+        self.autopx = False
+
+    # Access other components like this rather than by a regular attribute.
+    # This won't lookup the InteractiveShell object until it is used and
+    # then it is cached.  This is both efficient and couples this class 
+    # more loosely to InteractiveShell.
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    def _define_magics(self):
+        """Define the magic functions."""
+        self.shell.define_magic('result', self.magic_result)
+        self.shell.define_magic('px', self.magic_px)
+        self.shell.define_magic('autopx', self.magic_autopx)
+
+    def magic_result(self, ipself, parameter_s=''):
+        """Print the result of command i on all engines..
+
+        To use this a :class:`MultiEngineClient` instance must be created 
+        and then activated by calling its :meth:`activate` method.
+
+        Then you can do the following::
+
+            In [23]: %result
+            Out[23]: 
+            <Results List>
+            [0] In [6]: a = 10
+            [1] In [6]: a = 10
+    
+            In [22]: %result 6
+            Out[22]: 
+            <Results List>
+            [0] In [6]: a = 10
+            [1] In [6]: a = 10
+        """
+        if self.active_multiengine_client is None:
+            print NO_ACTIVE_MULTIENGINE_CLIENT
+            return
+
+        try:
+            index = int(parameter_s)
+        except:
+            index = None
+        result = self.active_multiengine_client.get_result(index)
+        return result
+
+    def magic_px(self, ipself, parameter_s=''):
+        """Executes the given python command in parallel.
+
+        To use this a :class:`MultiEngineClient` instance must be created 
+        and then activated by calling its :meth:`activate` method.
+        
+        Then you can do the following::
+
+            In [24]: %px a = 5
+            Parallel execution on engines: all
+            Out[24]: 
+            <Results List>
+            [0] In [7]: a = 5
+            [1] In [7]: a = 5
+        """
+
+        if self.active_multiengine_client is None:
+            print NO_ACTIVE_MULTIENGINE_CLIENT
+            return
+        print "Parallel execution on engines: %s" % self.active_multiengine_client.targets
+        result = self.active_multiengine_client.execute(parameter_s)
+        return result
+
+    def magic_autopx(self, ipself, parameter_s=''):
+        """Toggles auto parallel mode.
+
+        To use this a :class:`MultiEngineClient` instance must be created 
+        and then activated by calling its :meth:`activate` method. Once this
+        is called, all commands typed at the command line are send to
+        the engines to be executed in parallel. To control which engine
+        are used, set the ``targets`` attributed of the multiengine client
+        before entering ``%autopx`` mode.
+
+        Then you can do the following::
+
+            In [25]: %autopx
+            %autopx to enabled
+
+            In [26]: a = 10
+            <Results List>
+            [0] In [8]: a = 10
+            [1] In [8]: a = 10
+
+
+            In [27]: %autopx
+            %autopx disabled
+        """
+        if self.autopx:
+            self._disable_autopx()
+        else:
+            self._enable_autopx()
+
+    def _enable_autopx(self):
+        """Enable %autopx mode by saving the original runsource and installing 
+        pxrunsource.
+        """
+        if self.active_multiengine_client is None:
+            print NO_ACTIVE_MULTIENGINE_CLIENT
+            return
+
+        self._original_runsource = self.shell.runsource
+        self.shell.runsource = new.instancemethod(
+            self.pxrunsource, self.shell, self.shell.__class__
+        )
+        self.autopx = True
+        print "%autopx enabled"
+    
+    def _disable_autopx(self):
+        """Disable %autopx by restoring the original InteractiveShell.runsource."""
+        if self.autopx:
+            self.shell.runsource = self._original_runsource
+            self.autopx = False
+            print "%autopx disabled"
+
+    def pxrunsource(self, ipself, source, filename="<input>", symbol="single"):
+        """A parallel replacement for InteractiveShell.runsource."""
+
+        try:
+            code = ipself.compile(source, filename, symbol)
+        except (OverflowError, SyntaxError, ValueError):
+            # Case 1
+            ipself.showsyntaxerror(filename)
+            return None
+
+        if code is None:
+            # Case 2
+            return True
+
+        # Case 3
+        # Because autopx is enabled, we now call executeAll or disable autopx if
+        # %autopx or autopx has been called
+        if 'get_ipython().magic("%autopx' in source or 'get_ipython().magic("autopx' in source:
+            self._disable_autopx()
+            return False
+        else:
+            try:
+                result = self.active_multiengine_client.execute(source)
+            except:
+                ipself.showtraceback()
+            else:
+                print result.__repr__()
+            return False
+
+
+_loaded = False
+
+
+def load_ipython_extension(ip):
+    """Load the extension in IPython."""
+    global _loaded
+    if not _loaded:
+        prd = ParalleMagicComponent(ip, name='parallel_magic')
+        _loaded = True
+

IPython/config/profile/ipython_config_cluster.py

@@ -14,4 +14,11 b' from IPython.kernel.client import *'
 if hasattr(c.Global, 'exec_lines'):
     c.Global.exec_lines.append(lines)
 else:
-    c.Global.exec_lines = [lines]
  No newline at end of file
+    c.Global.exec_lines = [lines]
+
+# Load the parallelmagic extension to enable %result, %px, %autopx magics.
+if hasattr(c.Global, 'extensions'):
+    c.Global.extensions.append('parallelmagic')
+else:
+    c.Global.extensions = ['parallelmagic']
+

IPython/core/builtin_trap.py

@@ -86,6 +86,7 b' class BuiltinTrap(Component):'
         """Store ipython references in the __builtin__ namespace."""
         self.add_builtin('exit', Quitter(self.shell, 'exit'))
         self.add_builtin('quit', Quitter(self.shell, 'quit'))
+        self.add_builtin('get_ipython', self.shell.get_ipython)
 
         # Recursive reload function
         try:

IPython/kernel/multiengineclient.py

@@ -263,9 +263,13 b' class InteractiveMultiEngineClient(object):'
         """
         
         try:
-            __IPYTHON__.activeController = self
+            # This is injected into __builtins__.
+            ip = get_ipython()
         except NameError:
-            print "The IPython Controller magics only work within IPython."
+            print "The IPython parallel magics (%result, %px, %autopx) only work within IPython."
+        else:
+            pmagic = ip.get_component('parallel_magic')
+            pmagic.active_multiengine_client = self
                     
     def __setitem__(self, key, value):
         """Add a dictionary interface for pushing/pulling.