Create core.magics.auto according to new API.

IPython/core/magics/auto.py

@@ -0,0 +1,128 b''
+"""Implementation of execution-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  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
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from IPython.core.magic import Bunch, Magics, register_magics, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.warn import error
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@register_magics
+class AutoMagics(Magics):
+    """Magics that control various autoX behaviors."""
+
+    def __init__(self, shell):
+        super(AutoMagics, self).__init__(shell)
+        # namespace for holding state we may need
+        self._magic_state = Bunch()
+
+    @line_magic
+    def automagic(self, parameter_s=''):
+        """Make magic functions callable without having to type the initial %.
+
+        Without argumentsl toggles on/off (when off, you must call it as
+        %automagic, of course).  With arguments it sets the value, and you can
+        use any of (case insensitive):
+
+         - on, 1, True: to activate
+
+         - off, 0, False: to deactivate.
+
+        Note that magic functions have lowest priority, so if there's a
+        variable whose name collides with that of a magic fn, automagic won't
+        work for that function (you get the variable instead). However, if you
+        delete the variable (del var), the previously shadowed magic function
+        becomes visible to automagic again."""
+
+        arg = parameter_s.lower()
+        mman = self.shell.magics_manager
+        if arg in ('on', '1', 'true'):
+            val = True
+        elif arg in ('off', '0', 'false'):
+            val = False
+        else:
+            val = not mman.auto_magic
+        mman.auto_magic = val
+        print '\n' + self.shell.magics_manager.auto_status()
+
+    @skip_doctest
+    @line_magic
+    def autocall(self, parameter_s=''):
+        """Make functions callable without having to type parentheses.
+
+        Usage:
+
+           %autocall [mode]
+
+        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
+        value is toggled on and off (remembering the previous state).
+
+        In more detail, these values mean:
+
+        0 -> fully disabled
+
+        1 -> active, but do not apply if there are no arguments on the line.
+
+        In this mode, you get::
+
+          In [1]: callable
+          Out[1]: <built-in function callable>
+
+          In [2]: callable 'hello'
+          ------> callable('hello')
+          Out[2]: False
+
+        2 -> Active always.  Even if no arguments are present, the callable
+        object is called::
+
+          In [2]: float
+          ------> float()
+          Out[2]: 0.0
+
+        Note that even with autocall off, you can still use '/' at the start of
+        a line to treat the first argument on the command line as a function
+        and add parentheses to it::
+
+          In [8]: /str 43
+          ------> str(43)
+          Out[8]: '43'
+
+        # all-random (note for auto-testing)
+        """
+
+        if parameter_s:
+            arg = int(parameter_s)
+        else:
+            arg = 'toggle'
+
+        if not arg in (0, 1, 2,'toggle'):
+            error('Valid modes: (0->Off, 1->Smart, 2->Full')
+            return
+
+        if arg in (0, 1, 2):
+            self.shell.autocall = arg
+        else: # toggle
+            if self.shell.autocall:
+                self._magic_state.autocall_save = self.shell.autocall
+                self.shell.autocall = 0
+            else:
+                try:
+                    self.shell.autocall = self._magic_state.autocall_save
+                except AttributeError:
+                    self.shell.autocall = self._magic_state.autocall_save = 1
+
+        print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]

IPython/core/interactiveshell.py

@@ -2005,7 +2005,7 b' class InteractiveShell(SingletonConfigurable):'
         self.register_magic_function = self.magics_manager.register_function
         self.define_magic = self.magics_manager.define_magic
 
-        self.register_magics(mf.AutoMagics, m.BasicMagics, m.CodeMagics,
+        self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
             m.ConfigMagics, mf.DeprecatedMagics, m.ExecutionMagics,
             mf.ExtensionsMagics, m.HistoryMagics, mf.LoggingMagics,
             m.NamespaceMagics, mf.OSMagics, mf.PylabMagics )

IPython/core/magic_functions.py

@@ -67,113 +67,6 b' from IPython.utils.warn import warn, error'
 #-----------------------------------------------------------------------------
 
 @register_magics
-class AutoMagics(Magics):
-    """Magics that control various autoX behaviors."""
-
-    def __init__(self, shell):
-        super(AutoMagics, self).__init__(shell)
-        # namespace for holding state we may need
-        self._magic_state = Bunch()
-
-    @line_magic
-    def automagic(self, parameter_s=''):
-        """Make magic functions callable without having to type the initial %.
-
-        Without argumentsl toggles on/off (when off, you must call it as
-        %automagic, of course).  With arguments it sets the value, and you can
-        use any of (case insensitive):
-
-         - on, 1, True: to activate
-
-         - off, 0, False: to deactivate.
-
-        Note that magic functions have lowest priority, so if there's a
-        variable whose name collides with that of a magic fn, automagic won't
-        work for that function (you get the variable instead). However, if you
-        delete the variable (del var), the previously shadowed magic function
-        becomes visible to automagic again."""
-
-        arg = parameter_s.lower()
-        mman = self.shell.magics_manager
-        if arg in ('on', '1', 'true'):
-            val = True
-        elif arg in ('off', '0', 'false'):
-            val = False
-        else:
-            val = not mman.auto_magic
-        mman.auto_magic = val
-        print '\n' + self.shell.magics_manager.auto_status()
-
-    @skip_doctest
-    @line_magic
-    def autocall(self, parameter_s=''):
-        """Make functions callable without having to type parentheses.
-
-        Usage:
-
-           %autocall [mode]
-
-        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
-        value is toggled on and off (remembering the previous state).
-
-        In more detail, these values mean:
-
-        0 -> fully disabled
-
-        1 -> active, but do not apply if there are no arguments on the line.
-
-        In this mode, you get::
-
-          In [1]: callable
-          Out[1]: <built-in function callable>
-
-          In [2]: callable 'hello'
-          ------> callable('hello')
-          Out[2]: False
-
-        2 -> Active always.  Even if no arguments are present, the callable
-        object is called::
-
-          In [2]: float
-          ------> float()
-          Out[2]: 0.0
-
-        Note that even with autocall off, you can still use '/' at the start of
-        a line to treat the first argument on the command line as a function
-        and add parentheses to it::
-
-          In [8]: /str 43
-          ------> str(43)
-          Out[8]: '43'
-
-        # all-random (note for auto-testing)
-        """
-
-        if parameter_s:
-            arg = int(parameter_s)
-        else:
-            arg = 'toggle'
-
-        if not arg in (0, 1, 2,'toggle'):
-            error('Valid modes: (0->Off, 1->Smart, 2->Full')
-            return
-
-        if arg in (0, 1, 2):
-            self.shell.autocall = arg
-        else: # toggle
-            if self.shell.autocall:
-                self._magic_state.autocall_save = self.shell.autocall
-                self.shell.autocall = 0
-            else:
-                try:
-                    self.shell.autocall = self._magic_state.autocall_save
-                except AttributeError:
-                    self.shell.autocall = self._magic_state.autocall_save = 1
-
-        print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
-
-
-@register_magics
 class OSMagics(Magics):
     """Magics to interact with the underlying OS (shell-type functionality).
     """

IPython/core/magics/__init__.py

@@ -13,6 +13,7 b''
 #-----------------------------------------------------------------------------
 
 from IPython.core.magic import Magics, register_magics
+from .auto import AutoMagics
 from .basic import BasicMagics
 from .code import CodeMagics, MacroToEdit
 from .config import ConfigMagics