Renaming the special methods of the formatters.

The IPython formatters use special methods to compute the format
of objects. These special methods have names like "__html__", but
with this commit these have been changed to "_repr_html_".

I have also added a Javascript formatter and fixed a bug in
pylab tools in getfigs.

docs/examples/core/display.py

@@ -0,0 +1,26 b''
+"""Code that shows off the IPython display logic.
+"""
+
+from IPython.core.display import (
+    display, display_pretty, display_html,
+    display_svg, display_json
+)
+
+class Circle(object):
+
+    def __init__(self, radius):
+        self.radius = radius
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(u"\u25CB")
+
+    __pretty__ = _repr_pretty_
+
+    def _repr_html_(self):
+        return "<h1>Cirle: radius=%s</h1>" % self.radius
+
+    def _repr_svg_(self):
+        return """<svg>
+<circle cx="100" cy="50" r="40" stroke="black" stroke-width="2" fill="red"/>
+</svg>"""
+

IPython/core/display.py

@@ -1,122 +1,130 b''
 # -*- coding: utf-8 -*-
 """Top-level display functions for displaying object in different formats.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #       Copyright (C) 2008-2010 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
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Main functions
 #-----------------------------------------------------------------------------
 
 def display(*objs, **kwargs):
     """Display a Python object in all frontends.
 
     By default all representations will be computed and sent to the frontends.
     Frontends can decide which representation is used and how.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     include : list or tuple, optional
         A list of format type strings (MIME types) to include in the
         format data dict. If this is set *only* the format types included
         in this list will be computed.
     exclude : list or tuple, optional
         A list of format type string (MIME types) to exclue in the format
         data dict. If this is set all format types will be computed,
         except for those included in this argument.
     """
     include = kwargs.get('include')
     exclude = kwargs.get('exclude')
     
     from IPython.core.interactiveshell import InteractiveShell
     inst = InteractiveShell.instance()
     format = inst.display_formatter.format
     publish = inst.display_pub.publish
 
     for obj in objs:
         format_dict = format(obj, include=include, exclude=exclude)
         publish('IPython.core.display.display', format_dict)
 
 
 def display_pretty(*objs):
     """Display the pretty (default) representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     """
     display(*objs, include=['text/plain'])
 
 
 def display_html(*objs):
     """Display the HTML representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
         """
     display(*objs, include=['text/plain','text/html'])
 
 
 def display_svg(*objs):
     """Display the SVG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     """
     display(*objs, include=['text/plain','image/svg+xml'])
 
 
 def display_png(*objs):
     """Display the PNG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     """
     display(*objs, include=['text/plain','image/png'])
 
 
 def display_latex(*objs):
     """Display the LaTeX representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     """
     display(*objs, include=['text/plain','text/latex'])
 
 
 def display_json(*objs):
     """Display the JSON representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     """
     display(*objs, include=['text/plain','application/json'])
 
 
+def display_javascript(*objs):
+    """Display the Javascript representation of an object.
 
+    Parameters
+    ----------
+    objs : tuple of objects
+        The Python objects to display.
+    """
+    display(*objs, include=['text/plain','application/javascript'])

IPython/core/formatters.py

@@ -1,557 +1,576 b''
 # -*- coding: utf-8 -*-
 """Display formatters.
 
 
 Authors:
 
 * Robert Kern
 * Brian Granger
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2010, 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 imports
 import abc
 import sys
 # We must use StringIO, as cStringIO doesn't handle unicode properly.
 from StringIO import StringIO
 
 # Our own imports
 from IPython.config.configurable import Configurable
 from IPython.lib import pretty
 from IPython.utils.traitlets import Bool, Dict, Int, Str, CStr
 
 
 #-----------------------------------------------------------------------------
 # The main DisplayFormatter class
 #-----------------------------------------------------------------------------
 
 
 class DisplayFormatter(Configurable):
 
     # When set to true only the default plain text formatter will be used.
     plain_text_only = Bool(False, config=True)
 
     # A dict of formatter whose keys are format types (MIME types) and whose
     # values are subclasses of BaseFormatter.
     formatters = Dict(config=True)
     def _formatters_default(self):
         """Activate the default formatters."""
         formatter_classes = [
             PlainTextFormatter,
             HTMLFormatter,
             SVGFormatter,
             PNGFormatter,
             LatexFormatter,
-            JSONFormatter
+            JSONFormatter,
+            JavascriptFormatter
         ]
         d = {}
         for cls in formatter_classes:
             f = cls(config=self.config)
             d[f.format_type] = f
         return d
 
     def format(self, obj, include=None, exclude=None):
         """Return a format data dict for an object.
 
         By default all format types will be computed.
 
         The following MIME types are currently implemented:
 
         * text/plain
         * text/html
         * text/latex
         * application/json
         * image/png
         * immage/svg+xml
 
         Parameters
         ----------
         obj : object
             The Python object whose format data will be computed.
         include : list or tuple, optional
             A list of format type strings (MIME types) to include in the
             format data dict. If this is set *only* the format types included
             in this list will be computed.
         exclude : list or tuple, optional
             A list of format type string (MIME types) to exclue in the format
             data dict. If this is set all format types will be computed,
             except for those included in this argument.
 
         Returns
         -------
         format_dict : dict
             A dictionary of key/value pairs, one or each format that was
             generated for the object. The keys are the format types, which
             will usually be MIME type strings and the values and JSON'able
             data structure containing the raw data for the representation in
             that format.
         """
         format_dict = {}
 
         # If plain text only is active
         if self.plain_text_only:
             formatter = self.formatters['text/plain']
             try:
                 data = formatter(obj)
             except:
                 # FIXME: log the exception
                 raise
             if data is not None:
                 format_dict['text/plain'] = data
             return format_dict
 
         for format_type, formatter in self.formatters.items():
             if include is not None:
                 if format_type not in include:
                     continue
             if exclude is not None:
                 if format_type in exclude:
                     continue
             try:
                 data = formatter(obj)
             except:
                 # FIXME: log the exception
                 raise
             if data is not None:
                 format_dict[format_type] = data
         return format_dict
 
     @property
     def format_types(self):
         """Return the format types (MIME types) of the active formatters."""
         return self.formatters.keys()
 
 
 #-----------------------------------------------------------------------------
 # Formatters for specific format types (text, html, svg, etc.)
 #-----------------------------------------------------------------------------
 
 
 class FormatterABC(object):
     """ Abstract base class for Formatters.
 
     A formatter is a callable class that is responsible for computing the
     raw format data for a particular format type (MIME type). For example,
     an HTML formatter would have a format type of `text/html` and would return
     the HTML representation of the object when called.
     """
     __metaclass__ = abc.ABCMeta
 
     # The format type of the data returned, usually a MIME type.
     format_type = 'text/plain'
 
     # Is the formatter enabled...
     enabled = True
 
     @abc.abstractmethod
     def __call__(self, obj):
         """Return a JSON'able representation of the object.
 
         If the object cannot be formatted by this formatter, then return None
         """
         try:
             return repr(obj)
         except TypeError:
             return None
 
 
 class BaseFormatter(Configurable):
     """A base formatter class that is configurable.
 
     This formatter should usually be used as the base class of all formatters.
     It is a traited :class:`Configurable` class and includes an extensible
     API for users to determine how their objects are formatted. The following
     logic is used to find a function to format an given object.
 
     1. The object is introspected to see if it has a method with the name
        :attr:`print_method`. If is does, that object is passed to that method
        for formatting.
     2. If no print method is found, three internal dictionaries are consulted
        to find print method: :attr:`singleton_printers`, :attr:`type_printers`
        and :attr:`deferred_printers`.
 
     Users should use these dictionaries to register functions that will be
     used to compute the format data for their objects (if those objects don't
     have the special print methods). The easiest way of using these
     dictionaries is through the :meth:`for_type` and :meth:`for_type_by_name`
     methods.
 
     If no function/callable is found to compute the format data, ``None`` is
     returned and this format type is not used.
     """
 
     format_type = Str('text/plain')
 
     enabled = Bool(True, config=True)
 
     print_method = Str('__repr__')
 
     # The singleton printers.
     # Maps the IDs of the builtin singleton objects to the format functions.
     singleton_printers = Dict(config=True)
     def _singleton_printers_default(self):
         return {}
 
     # The type-specific printers.
     # Map type objects to the format functions.
     type_printers = Dict(config=True)
     def _type_printers_default(self):
         return {}
 
     # The deferred-import type-specific printers.
     # Map (modulename, classname) pairs to the format functions.
     deferred_printers = Dict(config=True)
     def _deferred_printers_default(self):
         return {}
 
     def __call__(self, obj):
         """Compute the format for an object."""
         if self.enabled:
             obj_id = id(obj)
             try:
                 obj_class = getattr(obj, '__class__', None) or type(obj)
-                if hasattr(obj_class, self.print_method):
-                    printer = getattr(obj_class, self.print_method)
-                    return printer(obj)
+                # First try to find registered singleton printers for the type.
                 try:
                     printer = self.singleton_printers[obj_id]
                 except (TypeError, KeyError):
                     pass
                 else:
                     return printer(obj)
+                # Next look for type_printers.
                 for cls in pretty._get_mro(obj_class):
                     if cls in self.type_printers:
                         return self.type_printers[cls](obj)
                     else:
                         printer = self._in_deferred_types(cls)
                         if printer is not None:
                             return printer(obj)
+                # Finally look for special method names.
+                if hasattr(obj_class, self.print_method):
+                    printer = getattr(obj_class, self.print_method)
+                    return printer(obj)
                 return None
             except Exception:
                 pass
         else:
             return None
 
     def for_type(self, typ, func):
         """Add a format function for a given type.
 
         Parameters
         -----------
         typ : class
             The class of the object that will be formatted using `func`.
         func : callable
             The callable that will be called to compute the format data. The
             call signature of this function is simple, it must take the
             object to be formatted and return the raw data for the given
             format. Subclasses may use a different call signature for the
             `func` argument.
         """
         oldfunc = self.type_printers.get(typ, None)
         if func is not None:
             # To support easy restoration of old printers, we need to ignore
             # Nones.
             self.type_printers[typ] = func
         return oldfunc
 
     def for_type_by_name(self, type_module, type_name, func):
         """Add a format function for a type specified by the full dotted
         module and name of the type, rather than the type of the object.
 
         Parameters
         ----------
         type_module : str
             The full dotted name of the module the type is defined in, like
             ``numpy``.
         type_name : str
             The name of the type (the class name), like ``dtype``
         func : callable
             The callable that will be called to compute the format data. The
             call signature of this function is simple, it must take the
             object to be formatted and return the raw data for the given
             format. Subclasses may use a different call signature for the
             `func` argument.
         """
         key = (type_module, type_name)
         oldfunc = self.deferred_printers.get(key, None)
         if func is not None:
             # To support easy restoration of old printers, we need to ignore
             # Nones.
             self.deferred_printers[key] = func
         return oldfunc
 
     def _in_deferred_types(self, cls):
         """
         Check if the given class is specified in the deferred type registry.
 
         Returns the printer from the registry if it exists, and None if the
         class is not in the registry. Successful matches will be moved to the
         regular type registry for future use.
         """
         mod = getattr(cls, '__module__', None)
         name = getattr(cls, '__name__', None)
         key = (mod, name)
         printer = None
         if key in self.deferred_printers:
             # Move the printer over to the regular registry.
             printer = self.deferred_printers.pop(key)
             self.type_printers[cls] = printer
         return printer
 
 
 class PlainTextFormatter(BaseFormatter):
     """The default pretty-printer.
 
     This uses :mod:`IPython.external.pretty` to compute the format data of
     the object. If the object cannot be pretty printed, :func:`repr` is used.
     See the documentation of :mod:`IPython.external.pretty` for details on
     how to write pretty printers.  Here is a simple example::
 
         def dtype_pprinter(obj, p, cycle):
             if cycle:
                 return p.text('dtype(...)')
             if hasattr(obj, 'fields'):
                 if obj.fields is None:
                     p.text(repr(obj))
                 else:
                     p.begin_group(7, 'dtype([')
                     for i, field in enumerate(obj.descr):
                         if i > 0:
                             p.text(',')
                             p.breakable()
                         p.pretty(field)
                     p.end_group(7, '])')
     """
 
     # The format type of data returned.
     format_type = Str('text/plain')
 
     # This subclass ignores this attribute as it always need to return
     # something.
     enabled = Bool(True, config=False)
 
     # Look for a __pretty__ methods to use for pretty printing.
     print_method = Str('__pretty__')
 
     # Whether to pretty-print or not.
     pprint = Bool(True, config=True)
 
     # Whether to be verbose or not.
     verbose = Bool(False, config=True)
 
     # The maximum width.
     max_width = Int(79, config=True)
 
     # The newline character.
     newline = Str('\n', config=True)
     
     # format-string for pprinting floats
     float_format = Str('%r')
     # setter for float precision, either int or direct format-string
     float_precision = CStr('', config=True)
     
     def _float_precision_changed(self, name, old, new):
         """float_precision changed, set float_format accordingly.
         
         float_precision can be set by int or str.
         This will set float_format, after interpreting input.
         If numpy has been imported, numpy print precision will also be set.
         
         integer `n` sets format to '%.nf', otherwise, format set directly.
         
         An empty string returns to defaults (repr for float, 8 for numpy).
         
         This parameter can be set via the '%precision' magic.
         """
         
         if '%' in new:
             # got explicit format string
             fmt = new
             try:
                 fmt%3.14159
             except Exception:
                 raise ValueError("Precision must be int or format string, not %r"%new)
         elif new:
             # otherwise, should be an int
             try:
                 i = int(new)
                 assert i >= 0
             except ValueError:
                 raise ValueError("Precision must be int or format string, not %r"%new)
             except AssertionError:
                 raise ValueError("int precision must be non-negative, not %r"%i)
             
             fmt = '%%.%if'%i
             if 'numpy' in sys.modules:
                 # set numpy precision if it has been imported
                 import numpy
                 numpy.set_printoptions(precision=i)
         else:
             # default back to repr
             fmt = '%r'
             if 'numpy' in sys.modules:
                 import numpy
                 # numpy default is 8
                 numpy.set_printoptions(precision=8)
         self.float_format = fmt
 
     # Use the default pretty printers from IPython.external.pretty.
     def _singleton_printers_default(self):
         return pretty._singleton_pprinters.copy()
 
     def _type_printers_default(self):
         d = pretty._type_pprinters.copy()
         d[float] = lambda obj,p,cycle: p.text(self.float_format%obj)
         return d
 
     def _deferred_printers_default(self):
         return pretty._deferred_type_pprinters.copy()
 
     #### FormatterABC interface ####
 
     def __call__(self, obj):
         """Compute the pretty representation of the object."""
         if not self.pprint:
             try:
                 return repr(obj)
             except TypeError:
                 return ''
         else:
             # This uses use StringIO, as cStringIO doesn't handle unicode.
             stream = StringIO()
             printer = pretty.RepresentationPrinter(stream, self.verbose,
                 self.max_width, self.newline,
                 singleton_pprinters=self.singleton_printers,
                 type_pprinters=self.type_printers,
                 deferred_pprinters=self.deferred_printers)
             printer.pretty(obj)
             printer.flush()
             return stream.getvalue()
 
 
 class HTMLFormatter(BaseFormatter):
     """An HTML formatter.
 
     To define the callables that compute the HTML representation of your
-    objects, define a :meth:`__html__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_html_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
     """
     format_type = Str('text/html')
 
-    print_method = Str('__html__')
+    print_method = Str('_repr_html_')
 
 
 class SVGFormatter(BaseFormatter):
     """An SVG formatter.
 
     To define the callables that compute the SVG representation of your
-    objects, define a :meth:`__svg__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_svg_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
     """
     format_type = Str('image/svg+xml')
 
-    print_method = Str('__svg__')
+    print_method = Str('_repr_svg_')
 
 
 class PNGFormatter(BaseFormatter):
     """A PNG formatter.
 
     To define the callables that compute the PNG representation of your
-    objects, define a :meth:`__png__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_png_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
-    this. The raw data should be the base64 encoded raw png data.
+    this.
+
+    The raw data should be the base64 encoded raw png data.
     """
     format_type = Str('image/png')
 
-    print_method = Str('__png__')
+    print_method = Str('_repr_png_')
 
 
 class LatexFormatter(BaseFormatter):
     """A LaTeX formatter.
 
     To define the callables that compute the LaTeX representation of your
-    objects, define a :meth:`__latex__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_latex_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
     """
     format_type = Str('text/latex')
 
-    print_method = Str('__latex__')
+    print_method = Str('_repr_latex_')
 
 
 class JSONFormatter(BaseFormatter):
     """A JSON string formatter.
 
     To define the callables that compute the JSON string representation of
-    your objects, define a :meth:`__json__` method or use the :meth:`for_type`
+    your objects, define a :meth:`_repr_json_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
     """
     format_type = Str('application/json')
 
-    print_method = Str('__json__')
+    print_method = Str('_repr_json_')
+
+
+class JavascriptFormatter(BaseFormatter):
+    """A Javascript formatter.
+
+    To define the callables that compute the Javascript representation of
+    your objects, define a :meth:`_repr_javascript_` method or use the 
+    :meth:`for_type` or :meth:`for_type_by_name` methods to register functions
+    that handle this.
+    """
+    format_type = Str('application/javascript')
 
+    print_method = Str('_repr_javascript_')
 
 FormatterABC.register(BaseFormatter)
 FormatterABC.register(PlainTextFormatter)
 FormatterABC.register(HTMLFormatter)
 FormatterABC.register(SVGFormatter)
 FormatterABC.register(PNGFormatter)
 FormatterABC.register(LatexFormatter)
 FormatterABC.register(JSONFormatter)
+FormatterABC.register(JavascriptFormatter)
 
 
 def format_display_data(obj, include=None, exclude=None):
     """Return a format data dict for an object.
 
     By default all format types will be computed.
 
     The following MIME types are currently implemented:
 
     * text/plain
     * text/html
     * text/latex
     * application/json
     * image/png
     * immage/svg+xml
 
     Parameters
     ----------
     obj : object
         The Python object whose format data will be computed.
 
     Returns
     -------
     format_dict : dict
         A dictionary of key/value pairs, one or each format that was
         generated for the object. The keys are the format types, which
         will usually be MIME type strings and the values and JSON'able
         data structure containing the raw data for the representation in
         that format.
     include : list or tuple, optional
         A list of format type strings (MIME types) to include in the
         format data dict. If this is set *only* the format types included
         in this list will be computed.
     exclude : list or tuple, optional
         A list of format type string (MIME types) to exclue in the format
         data dict. If this is set all format types will be computed,
         except for those included in this argument.
     """
     from IPython.core.interactiveshell import InteractiveShell
 
     InteractiveShell.instance().display_formatter.format(
         obj,
         include,
         exclude
     )

IPython/core/usage.py

@@ -1,509 +1,509 b''
 # -*- coding: utf-8 -*-
 """Usage information for the main IPython applications.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  The IPython Development Team
 #  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 import sys
 from IPython.core import release
 
 cl_usage = """\
 ipython [options] [files]
 
 IPython: an enhanced interactive Python shell.
 
     A Python shell with automatic history (input and output), dynamic object
     introspection, easier configuration, command completion, access to the
     system shell and more.  IPython can also be embedded in running programs.
 
     If invoked with no options, it executes all the files listed in sequence
     and exits, use -i to enter interactive mode after running the files.  Files
     ending in .py will be treated as normal Python, but files ending in .ipy
     can contain special IPython syntax (magic commands, shell expansions, etc.)
 
     Please note that some of the configuration options are not available at the
     command line, simply because they are not practical here. Look into your
     ipython_config.py configuration file for details on those.
 
     This file is typically installed in the IPYTHON_DIR directory. For Linux
     users, this will be $HOME/.config/ipython, and for other users it will be
     $HOME/.ipython.  For Windows users, $HOME resolves to C:\\Documents and
     Settings\\YourUserName in most instances.
 
     In IPython's documentation, we will refer to this directory as IPYTHON_DIR,
     you can change its default location by setting any path you want in this
     environment variable.
 
     For more information, see the manual available in HTML and PDF in your
     installation, or online at http://ipython.scipy.org.
 """
 
 interactive_usage = """
 IPython -- An enhanced Interactive Python
 =========================================
 
 IPython offers a combination of convenient shell features, special commands
 and a history mechanism for both input (command history) and output (results
 caching, similar to Mathematica). It is intended to be a fully compatible
 replacement for the standard Python interpreter, while offering vastly
 improved functionality and flexibility.
 
 At your system command line, type 'ipython -help' to see the command line
 options available. This document only describes interactive features.
 
 Warning: IPython relies on the existence of a global variable called __IP which
 controls the shell itself. If you redefine __IP to anything, bizarre behavior
 will quickly occur.
 
 MAIN FEATURES
 
 * Access to the standard Python help. As of Python 2.1, a help system is
   available with access to object docstrings and the Python manuals. Simply
   type 'help' (no quotes) to access it.
 
 * Magic commands: type %magic for information on the magic subsystem.
 
 * System command aliases, via the %alias command or the ipythonrc config file.
 
 * Dynamic object information:
 
   Typing ?word or word? prints detailed information about an object.  If
   certain strings in the object are too long (docstrings, code, etc.) they get
   snipped in the center for brevity.
 
   Typing ??word or word?? gives access to the full information without
   snipping long strings. Long strings are sent to the screen through the less
   pager if longer than the screen, printed otherwise.
 
   The ?/?? system gives access to the full source code for any object (if
   available), shows function prototypes and other useful information.
 
   If you just want to see an object's docstring, type '%pdoc object' (without
   quotes, and without % if you have automagic on).
 
   Both %pdoc and ?/?? give you access to documentation even on things which are
   not explicitely defined. Try for example typing {}.get? or after import os,
   type os.path.abspath??. The magic functions %pdef, %source and %file operate
   similarly.
 
 * Completion in the local namespace, by typing TAB at the prompt.
 
   At any time, hitting tab will complete any available python commands or
   variable names, and show you a list of the possible completions if there's
   no unambiguous one. It will also complete filenames in the current directory.
 
   This feature requires the readline and rlcomplete modules, so it won't work
   if your Python lacks readline support (such as under Windows).
 
 * Search previous command history in two ways (also requires readline):
 
   - Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to
   search through only the history items that match what you've typed so
   far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like
   normal arrow keys.
 
   - Hit Ctrl-r: opens a search prompt. Begin typing and the system searches
   your history for lines that match what you've typed so far, completing as
   much as it can.
 
 * Persistent command history across sessions (readline required).
 
 * Logging of input with the ability to save and restore a working session.
   
 * System escape with !. Typing !ls will run 'ls' in the current directory.
 
 * The reload command does a 'deep' reload of a module: changes made to the
   module since you imported will actually be available without having to exit.
 
 * Verbose and colored exception traceback printouts. See the magic xmode and
   xcolor functions for details (just type %magic).
 
 * Input caching system:
 
   IPython offers numbered prompts (In/Out) with input and output caching. All
   input is saved and can be retrieved as variables (besides the usual arrow
   key recall).
 
   The following GLOBAL variables always exist (so don't overwrite them!):
   _i: stores previous input.
   _ii: next previous.
   _iii: next-next previous.
   _ih : a list of all input _ih[n] is the input from line n.
 
   Additionally, global variables named _i<n> are dynamically created (<n>
   being the prompt counter), such that _i<n> == _ih[<n>]
 
   For example, what you typed at prompt 14 is available as _i14 and _ih[14].
 
   You can create macros which contain multiple input lines from this history,
   for later re-execution, with the %macro function.
 
   The history function %hist allows you to see any part of your input history
   by printing a range of the _i variables. Note that inputs which contain
   magic functions (%) appear in the history with a prepended comment. This is
   because they aren't really valid Python code, so you can't exec them.
 
 * Output caching system:
 
   For output that is returned from actions, a system similar to the input
   cache exists but using _ instead of _i. Only actions that produce a result
   (NOT assignments, for example) are cached. If you are familiar with
   Mathematica, IPython's _ variables behave exactly like Mathematica's %
   variables.
 
   The following GLOBAL variables always exist (so don't overwrite them!):
   _ (one underscore): previous output.
   __ (two underscores): next previous.
   ___ (three underscores): next-next previous.
 
   Global variables named _<n> are dynamically created (<n> being the prompt
   counter), such that the result of output <n> is always available as _<n>.
 
   Finally, a global dictionary named _oh exists with entries for all lines
   which generated output.
 
 * Directory history:
 
   Your history of visited directories is kept in the global list _dh, and the
   magic %cd command can be used to go to any entry in that list.
 
 * Auto-parentheses and auto-quotes (adapted from Nathan Gray's LazyPython)
 
     1. Auto-parentheses
         Callable objects (i.e. functions, methods, etc) can be invoked like
         this (notice the commas between the arguments):
             >>> callable_ob arg1, arg2, arg3
         and the input will be translated to this:
             --> callable_ob(arg1, arg2, arg3)
         You can force auto-parentheses by using '/' as the first character
         of a line.  For example:
             >>> /globals             # becomes 'globals()'
         Note that the '/' MUST be the first character on the line!  This
         won't work:
             >>> print /globals    # syntax error
             
         In most cases the automatic algorithm should work, so you should
         rarely need to explicitly invoke /. One notable exception is if you
         are trying to call a function with a list of tuples as arguments (the
         parenthesis will confuse IPython):
             In [1]: zip (1,2,3),(4,5,6)  # won't work
         but this will work:
             In [2]: /zip (1,2,3),(4,5,6)
             ------> zip ((1,2,3),(4,5,6))
             Out[2]= [(1, 4), (2, 5), (3, 6)]        
 
         IPython tells you that it has altered your command line by
         displaying the new command line preceded by -->.  e.g.:
             In [18]: callable list
             -------> callable (list) 
 
     2. Auto-Quoting
         You can force auto-quoting of a function's arguments by using ',' as
         the first character of a line.  For example:
             >>> ,my_function /home/me   # becomes my_function("/home/me")
 
         If you use ';' instead, the whole argument is quoted as a single
         string (while ',' splits on whitespace):
             >>> ,my_function a b c   # becomes my_function("a","b","c")
             >>> ;my_function a b c   # becomes my_function("a b c")
 
         Note that the ',' MUST be the first character on the line!  This
         won't work:
             >>> x = ,my_function /home/me    # syntax error
 """
 
 interactive_usage_min =  """\
 An enhanced console for Python.
 Some of its features are:
 - Readline support if the readline library is present.
 - Tab completion in the local namespace.
 - Logging of input, see command-line options.
 - System shell escape via ! , eg !ls.
 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
 - Keeps track of locally defined variables via %who, %whos.
 - Show object information with a ? eg ?x or x? (use ?? for more info).
 """
 
 quick_reference = r"""
 IPython -- An enhanced Interactive Python - Quick Reference Card
 ================================================================
 
 obj?, obj??      : Get help, or more help for object (also works as
                    ?obj, ??obj).
 ?foo.*abc*       : List names in 'foo' containing 'abc' in them.
 %magic           : Information about IPython's 'magic' % functions.
 
 Magic functions are prefixed by %, and typically take their arguments without
 parentheses, quotes or even commas for convenience.
  
 Example magic function calls:
 
 %alias d ls -F   : 'd' is now an alias for 'ls -F'
 alias d ls -F    : Works if 'alias' not a python name
 alist = %alias   : Get list of aliases to 'alist'
 cd /usr/share    : Obvious. cd -<tab> to choose from visited dirs.
 %cd??            : See help AND source for magic %cd
 
 System commands:
     
 !cp a.txt b/     : System command escape, calls os.system()
 cp a.txt b/      : after %rehashx, most system commands work without !
 cp ${f}.txt $bar : Variable expansion in magics and system commands
 files = !ls /usr : Capture sytem command output
 files.s, files.l, files.n: "a b c", ['a','b','c'], 'a\nb\nc'
 
 History:
 
 _i, _ii, _iii    : Previous, next previous, next next previous input
 _i4, _ih[2:5]    : Input history line 4, lines 2-4
 exec _i81        : Execute input history line #81 again
 %rep 81          : Edit input history line #81        
 _, __, ___       : previous, next previous, next next previous output
 _dh              : Directory history
 _oh              : Output history
 %hist            : Command history. '%hist -g foo' search history for 'foo'
 
 Autocall:
 
 f 1,2            : f(1,2)
 /f 1,2           : f(1,2) (forced autoparen)
 ,f 1 2           : f("1","2")
 ;f 1 2           : f("1 2")
 
 Remember: TAB completion works in many contexts, not just file names
 or python names.
 
 The following magic functions are currently available:
 
 """
 
 gui_reference = """\
 ===============================
  The graphical IPython console
 ===============================
 
 This console is designed to emulate the look, feel and workflow of a terminal
 environment, while adding a number of enhancements that are simply not possible
 in a real terminal, such as inline syntax highlighting, true multiline editing,
 inline graphics and much more.
 
 This quick reference document contains the basic information you'll need to
 know to make the most efficient use of it.  For the various command line
 options available at startup, type ``--help`` at the command line.
 
 
 Multiline editing
 =================
 
 The graphical console is capable of true multiline editing, but it also tries
 to behave intuitively like a terminal when possible.  If you are used to
 IPyhton's old terminal behavior, you should find the transition painless, and
 once you learn a few basic keybindings it will be a much more efficient
 environment.
 
 For single expressions or indented blocks, the console behaves almost like the
 terminal IPython: single expressions are immediately evaluated, and indented
 blocks are evaluated once a single blank line is entered::
 
     In [1]: print "Hello IPython!"  # Enter was pressed at the end of the line
     Hello IPython!
     
     In [2]: for i in range(10):
        ...: 	print i,
        ...: 	
     0 1 2 3 4 5 6 7 8 9
 
 If you want to enter more than one expression in a single input block
 (something not possible in the terminal), you can use ``Control-Enter`` at the
 end of your first line instead of ``Enter``.  At that point the console goes
 into 'cell mode' and even if your inputs are not indented, it will continue
 accepting arbitrarily many lines until either you enter an extra blank line or
 you hit ``Shift-Enter`` (the key binding that forces execution).  When a
 multiline cell is entered, IPython analyzes it and executes its code producing
 an ``Out[n]`` prompt only for the last expression in it, while the rest of the
 cell is executed as if it was a script.  An example should clarify this::
 
     In [3]: x=1  # Hit C-Enter here
        ...: y=2  # from now on, regular Enter is sufficient
        ...: z=3
        ...: x**2  # This does *not* produce an Out[] value
        ...: x+y+z  # Only the last expression does
        ...: 
     Out[3]: 6
 
 The behavior where an extra blank line forces execution is only active if you
 are actually typing at the keyboard each line, and is meant to make it mimic
 the IPython terminal behavior.  If you paste a long chunk of input (for example
 a long script copied form an editor or web browser), it can contain arbitrarily
 many intermediate blank lines and they won't cause any problems.  As always,
 you can then make it execute by appending a blank line *at the end* or hitting
 ``Shift-Enter`` anywhere within the cell.
 
 With the up arrow key, you can retrieve previous blocks of input that contain
 multiple lines.  You can move inside of a multiline cell like you would in any
 text editor.  When you want it executed, the simplest thing to do is to hit the
 force execution key, ``Shift-Enter`` (though you can also navigate to the end
 and append a blank line by using ``Enter`` twice).
 
 If you've edited a multiline cell and accidentally navigate out of it with the
 up or down arrow keys, IPython will clear the cell and replace it with the
 contents of the one above or below that you navigated to.  If this was an
 accident and you want to retrieve the cell you were editing, use the Undo
 keybinding, ``Control-z``.
 
 
 Key bindings
 ============
 
 The IPython console supports most of the basic Emacs line-oriented keybindings,
 in addition to some of its own.
 
 The keybinding prefixes mean:
 
 - ``C``: Control
 - ``S``: Shift
 - ``M``: Meta (typically the Alt key)
 
 The keybindings themselves are:
 
 - ``Enter``: insert new line (may cause execution, see above).
 - ``C-Enter``: force new line, *never* causes execution.
 - ``S-Enter``: *force* execution regardless of where cursor is, no newline added.
 - ``C-c``: copy highlighted text to clipboard (prompts are automatically stripped).
 - ``C-S-c``: copy highlighted text to clipboard (prompts are not stripped).
 - ``C-v``: paste text from clipboard.
 - ``C-z``: undo (retrieves lost text if you move out of a cell with the arrows).
 - ``C-S-z``: redo.
 - ``C-o``: move to 'other' area, between pager and terminal.
 - ``C-l``: clear terminal.
 - ``C-a``: go to beginning of line.
 - ``C-e``: go to end of line.
 - ``C-k``: kill from cursor to the end of the line.
 - ``C-y``: yank (paste)
 - ``C-p``: previous line (like up arrow)
 - ``C-n``: next line (like down arrow)
 - ``C-f``: forward (like right arrow)
 - ``C-b``: back (like left arrow)
 - ``C-d``: delete next character.
 - ``M-<``: move to the beginning of the input region.
 - ``M->``: move to the end of the input region.
 - ``M-d``: delete next word.
 - ``M-Backspace``: delete previous word.
 - ``C-.``: force a kernel restart (a confirmation dialog appears).
 - ``C-+``: increase font size.
 - ``C--``: decrease font size.
 
 The IPython pager
 =================
 
 IPython will show long blocks of text from many sources using a builtin pager.
 You can control where this pager appears with the ``--paging`` command-line
 flag:
 
 - ``inside`` [default]: the pager is overlaid on top of the main terminal. You
   must quit the pager to get back to the terminal (similar to how a pager such
   as ``less`` or ``more`` works).
 
 - ``vsplit``: the console is made double-tall, and the pager appears on the
   bottom area when needed.  You can view its contents while using the terminal.
 
 - ``hsplit``: the console is made double-wide, and the pager appears on the
   right area when needed.  You can view its contents while using the terminal.
 
 - ``none``: the console never pages output.
 
 If you use the vertical or horizontal paging modes, you can navigate between
 terminal and pager as follows:
 
 - Tab key: goes from pager to terminal (but not the other way around).
 - Control-o: goes from one to another always.
 - Mouse: click on either.
 
 In all cases, the ``q`` or ``Escape`` keys quit the pager (when used with the
 focus on the pager area).
 
 Running subprocesses
 ====================
 
 The graphical IPython console uses the ``pexpect`` module to run subprocesses
 when you type ``!command``.  This has a number of advantages (true asynchronous
 output from subprocesses as well as very robust termination of rogue
 subprocesses with ``Control-C``), as well as some limitations.  The main
 limitation is that you can *not* interact back with the subprocess, so anything
 that invokes a pager or expects you to type input into it will block and hang
 (you can kill it with ``Control-C``).
 
 We have provided as magics ``%less`` to page files (aliased to ``%more``),
 ``%clear`` to clear the terminal, and ``%man`` on Linux/OSX.  These cover the
 most common commands you'd want to call in your subshell and that would cause
 problems if invoked via ``!cmd``, but you need to be aware of this limitation.
 
 Display
 =======
 
 The IPython console can now display objects in a variety of formats, including
 HTML, PNG and SVG. This is accomplished using the display functions in
 ``IPython.core.display``::
 
     In [4]: from IPython.core.display import display, display_html
 
     In [5]: from IPython.core.display import display_png, display_svg
 
 Python objects can simply be passed to these functions and the appropriate
 representations will be displayed in the console as long as the objects know
 how to compute those representations. The easiest way of teaching objects how
 to format themselves in various representations is to define special methods
-such as: ``__html``, ``__svg__`` and ``__png__``. IPython's display formatters
+such as: ``_repr_html_``, ``_repr_svg_`` and ``_repr_png_``. IPython's display formatters
 can also be given custom formatter functions for various types::
 
     In [6]: ip = get_ipython()
 
     In [7]: html_formatter = ip.display_formatter.formatters['text/html']
 
     In [8]: html_formatter.for_type(Foo, foo_to_html)
 
 For further details, see ``IPython.core.formatters``.
 
 Inline matplotlib graphics
 ==========================
 
 The IPython console is capable of displaying matplotlib figures inline, in SVG
 format.  If started with the ``--pylab inline`` flag, then all figures are
 rendered inline automatically.  If started with ``--pylab`` or ``--pylab <your
 backend>``, then a GUI backend will be used, but IPython's ``display()`` and
 ``getfigs()`` functions can be used to view plots inline::
 
     In [9]: display(*getfigs())    # display all figures inline
 
     In[10]: display(*getfigs(1,2)) # display figures 1 and 2 inline
 """
 
 
 quick_guide = """\
 ?         -> Introduction and overview of IPython's features.
 %quickref -> Quick reference.
 help      -> Python's own help system.
 object?   -> Details about 'object', use 'object??' for extra details.
 """
 
 gui_note = """\
 %guiref   -> A brief reference about the graphical user interface.
 """
 
 default_banner_parts = [
     'Python %s\n' % (sys.version.split('\n')[0],),
     'Type "copyright", "credits" or "license" for more information.\n\n',
     'IPython %s -- An enhanced Interactive Python.\n' % (release.version,),
     quick_guide
 ]
 
 default_gui_banner_parts = default_banner_parts + [gui_note]
 
 default_banner = ''.join(default_banner_parts)
 
 default_gui_banner = ''.join(default_gui_banner_parts)

IPython/extensions/sympy_printing.py

@@ -1,70 +1,70 b''
 """A print function that pretty prints sympy Basic objects.
 
 Authors:
 * Brian Granger
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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
 #-----------------------------------------------------------------------------
 
 from IPython.lib.latextools import latex_to_png
 from IPython.testing import decorators as dec
 # use @dec.skipif_not_sympy to skip tests requiring sympy
 
 try:
     from sympy import pretty, latex
 except ImportError:
     pass
 
 
 #-----------------------------------------------------------------------------
 # Definitions of magic functions for use with IPython
 #-----------------------------------------------------------------------------
 
 def print_basic_unicode(o, p, cycle):
     """A function to pretty print sympy Basic objects."""
     if cycle:
         return p.text('Basic(...)')
     out = pretty(o, use_unicode=True)
     if '\n' in out:
         p.text(u'\n')
     p.text(out)
 
 
 def print_png(o):
-    """A funciton to display sympy expression using LaTex -> PNG."""
+    """A function to display sympy expression using LaTex -> PNG."""
     s = latex(o, mode='inline')
     # mathtext does not understand certain latex flags, so we try to replace
     # them with suitable subs.
     s = s.replace('\\operatorname','')
     s = s.replace('\\overline', '\\bar')
     png = latex_to_png(s, encode=True)
     return png
 
 _loaded = False
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
     global _loaded
     if not _loaded:
         plaintext_formatter = ip.display_formatter.formatters['text/plain']
         plaintext_formatter.for_type_by_name(
             'sympy.core.basic', 'Basic', print_basic_unicode
         )
         plaintext_formatter.for_type_by_name(
             'sympy.matrices.matrices', 'Matrix', print_basic_unicode
         )
 
         png_formatter = ip.display_formatter.formatters['image/png']
         png_formatter.for_type_by_name(
             'sympy.core.basic', 'Basic', print_png
         )
         _loaded = True
 

IPython/lib/pylabtools.py

@@ -1,299 +1,300 b''
 # -*- coding: utf-8 -*-
 """Pylab (matplotlib) support utilities.
 
 Authors
 -------
 
 * Fernando Perez.
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 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
 #-----------------------------------------------------------------------------
 
 from cStringIO import StringIO
 
 from IPython.utils.decorators import flag_calls
 
 # If user specifies a GUI, that dictates the backend, otherwise we read the
 # user's mpl default from the mpl rc structure
 backends = {'tk': 'TkAgg',
             'gtk': 'GTKAgg',
             'wx': 'WXAgg',
             'qt': 'Qt4Agg', # qt3 not supported
             'qt4': 'Qt4Agg',
             'osx': 'MacOSX',
             'inline' : 'module://IPython.zmq.pylab.backend_inline'}
 
 #-----------------------------------------------------------------------------
 # Matplotlib utilities
 #-----------------------------------------------------------------------------
 
 
 def getfigs(*fig_nums):
     """Get a list of matplotlib figures by figure numbers.
 
     If no arguments are given, all available figures are returned.  If the
     argument list contains references to invalid figures, a warning is printed
     but the function continues pasting further figures.
 
     Parameters
     ----------
     figs : tuple
         A tuple of ints giving the figure numbers of the figures to return.
     """
     from matplotlib._pylab_helpers import Gcf
     if not fig_nums:
         fig_managers = Gcf.get_all_fig_managers()
         return [fm.canvas.figure for fm in fig_managers]
     else:
         figs = []
         for num in fig_nums:
             f = Gcf.figs.get(num)
             if f is None:
                 print('Warning: figure %s not available.' % num)
+            else:
             figs.append(f.canvas.figure)
         return figs
 
 
 def figsize(sizex, sizey):
     """Set the default figure size to be [sizex, sizey].
 
     This is just an easy to remember, convenience wrapper that sets::
 
       matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
     """
     import matplotlib
     matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
 
 
 def figure_to_svg(fig):
     """Convert a figure to svg for inline display."""
     # When there's an empty figure, we shouldn't return anything, otherwise we
     # get big blank areas in the qt console.
     if not fig.axes:
         return
 
     fc = fig.get_facecolor()
     ec = fig.get_edgecolor()
     fig.set_facecolor('white')
     fig.set_edgecolor('white')
     try:
         string_io = StringIO()
         fig.canvas.print_figure(string_io, format='svg')
         svg = string_io.getvalue()
     finally:
         fig.set_facecolor(fc)
         fig.set_edgecolor(ec)
     return svg
 
 
 # We need a little factory function here to create the closure where
 # safe_execfile can live.
 def mpl_runner(safe_execfile):
     """Factory to return a matplotlib-enabled runner for %run.
 
     Parameters
     ----------
     safe_execfile : function
       This must be a function with the same interface as the
       :meth:`safe_execfile` method of IPython.
 
     Returns
     -------
     A function suitable for use as the ``runner`` argument of the %run magic
     function.
     """
     
     def mpl_execfile(fname,*where,**kw):
         """matplotlib-aware wrapper around safe_execfile.
 
         Its interface is identical to that of the :func:`execfile` builtin.
 
         This is ultimately a call to execfile(), but wrapped in safeties to
         properly handle interactive rendering."""
 
         import matplotlib
         import matplotlib.pylab as pylab
 
         #print '*** Matplotlib runner ***' # dbg
         # turn off rendering until end of script
         is_interactive = matplotlib.rcParams['interactive']
         matplotlib.interactive(False)
         safe_execfile(fname,*where,**kw)
         matplotlib.interactive(is_interactive)
         # make rendering call now, if the user tried to do it
         if pylab.draw_if_interactive.called:
             pylab.draw()
             pylab.draw_if_interactive.called = False
 
     return mpl_execfile
 
 
 #-----------------------------------------------------------------------------
 # Code for initializing matplotlib and importing pylab
 #-----------------------------------------------------------------------------
 
 
 def find_gui_and_backend(gui=None):
     """Given a gui string return the gui and mpl backend.
 
     Parameters
     ----------
     gui : str
         Can be one of ('tk','gtk','wx','qt','qt4','inline').
 
     Returns
     -------
     A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
     'WXAgg','Qt4Agg','module://IPython.zmq.pylab.backend_inline').
     """
 
     import matplotlib
 
     if gui:
         # select backend based on requested gui
         backend = backends[gui]
     else:
         backend = matplotlib.rcParams['backend']
         # In this case, we need to find what the appropriate gui selection call
         # should be for IPython, so we can activate inputhook accordingly
         g2b = backends  # maps gui names to mpl backend names
         b2g = dict(zip(g2b.values(), g2b.keys()))  # reverse dict
         gui = b2g.get(backend, None)
     return gui, backend
 
 
 def activate_matplotlib(backend):
     """Activate the given backend and set interactive to True."""
 
     import matplotlib
     if backend.startswith('module://'):
         # Work around bug in matplotlib: matplotlib.use converts the
         # backend_id to lowercase even if a module name is specified!
         matplotlib.rcParams['backend'] = backend
     else:
         matplotlib.use(backend)
     matplotlib.interactive(True)
 
     # This must be imported last in the matplotlib series, after
     # backend/interactivity choices have been made
     import matplotlib.pylab as pylab
 
     # XXX For now leave this commented out, but depending on discussions with
     # mpl-dev, we may be able to allow interactive switching...
     #import matplotlib.pyplot
     #matplotlib.pyplot.switch_backend(backend)
 
     pylab.show._needmain = False
     # We need to detect at runtime whether show() is called by the user.
     # For this, we wrap it into a decorator which adds a 'called' flag.
     pylab.draw_if_interactive = flag_calls(pylab.draw_if_interactive)
 
 
 def import_pylab(user_ns, backend, import_all=True, shell=None):
     """Import the standard pylab symbols into user_ns."""
 
     # Import numpy as np/pyplot as plt are conventions we're trying to
     # somewhat standardize on.  Making them available to users by default
     # will greatly help this.
     s = ("import numpy\n"
           "import matplotlib\n"
           "from matplotlib import pylab, mlab, pyplot\n"
           "np = numpy\n"
           "plt = pyplot\n"
           )
     exec s in user_ns
 
     if shell is not None:
         exec s in shell.user_ns_hidden
         # If using our svg payload backend, register the post-execution
         # function that will pick up the results for display.  This can only be
         # done with access to the real shell object.
         if backend == backends['inline']:
             from IPython.zmq.pylab.backend_inline import flush_svg
             from matplotlib import pyplot
             shell.register_post_execute(flush_svg)
             # The typical default figure size is too large for inline use,
             # so we shrink the figure size to 6x4, and tweak fonts to
             # make that fit.  This is configurable via Global.pylab_inline_rc,
             # or rather it will be once the zmq kernel is hooked up to
             # the config system.
             
             default_rc = {
                 'figure.figsize': (6.0,4.0),
                 # 12pt labels get cutoff on 6x4 logplots, so use 10pt.
                 'font.size': 10,
                 # 10pt still needs a little more room on the xlabel:
                 'figure.subplot.bottom' : .125
             }
             rc = getattr(shell.config.Global, 'pylab_inline_rc', default_rc)
             pyplot.rcParams.update(rc)
             shell.config.Global.pylab_inline_rc = rc
             
             # Add 'figsize' to pyplot and to the user's namespace
             user_ns['figsize'] = pyplot.figsize = figsize
             shell.user_ns_hidden['figsize'] = figsize
         
         # The old pastefig function has been replaced by display
         # Always add this svg formatter so display works.
         from IPython.core.display import display, display_svg
         svg_formatter = shell.display_formatter.formatters['image/svg+xml']
         svg_formatter.for_type_by_name(
             'matplotlib.figure','Figure',figure_to_svg
         )
         # Add display and display_png to the user's namespace
         user_ns['display'] = display
         shell.user_ns_hidden['display'] = display
         user_ns['display_svg'] = display_svg
         shell.user_ns_hidden['display_svg'] = display_svg
         user_ns['getfigs'] = getfigs
         shell.user_ns_hidden['getfigs'] = getfigs
 
     if import_all:
         s = ("from matplotlib.pylab import *\n"
              "from numpy import *\n")
         exec s in user_ns
         if shell is not None:
             exec s in shell.user_ns_hidden
 
 
 def pylab_activate(user_ns, gui=None, import_all=True):
     """Activate pylab mode in the user's namespace.
 
     Loads and initializes numpy, matplotlib and friends for interactive use.
 
     Parameters
     ----------
     user_ns : dict
       Namespace where the imports will occur.
 
     gui : optional, string
       A valid gui name following the conventions of the %gui magic.
 
     import_all : optional, boolean
       If true, an 'import *' is done from numpy and pylab.
 
     Returns
     -------
     The actual gui used (if not given as input, it was obtained from matplotlib
     itself, and will be needed next to configure IPython's gui integration.
     """
     gui, backend = find_gui_and_backend(gui)
     activate_matplotlib(backend)
     import_pylab(user_ns, backend)
 
     print """
 Welcome to pylab, a matplotlib-based Python environment [backend: %s].
 For more information, type 'help(pylab)'.""" % backend
     
     return gui