Changes to Math class and added Latex class.

* Math now adds $$ if the user doesn't provide them.
* Latex is like Math, but doesn't add delimiters.

IPython/core/display.py

@@ -1,434 +1,441 b''
 # -*- coding: utf-8 -*-
 """Top-level display functions for displaying object in different formats.
 
 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 xml.dom import minidom
 
 from .displaypub import (
     publish_pretty, publish_html,
     publish_latex, publish_svg,
     publish_png, publish_json,
     publish_javascript, publish_jpeg
 )
 
 #-----------------------------------------------------------------------------
 # 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, **kwargs):
     """Display the pretty (default) representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw text data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_pretty(obj)
     else:
         display(*objs, include=['text/plain'])
 
 
 def display_html(*objs, **kwargs):
     """Display the HTML representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw HTML data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_html(obj)
     else:
         display(*objs, include=['text/plain','text/html'])
 
 
 def display_svg(*objs, **kwargs):
     """Display the SVG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw svg data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_svg(obj)
     else:
         display(*objs, include=['text/plain','image/svg+xml'])
 
 
 def display_png(*objs, **kwargs):
     """Display the PNG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw png data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_png(obj)
     else:
         display(*objs, include=['text/plain','image/png'])
 
 
 def display_jpeg(*objs, **kwargs):
     """Display the JPEG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw JPEG data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_jpeg(obj)
     else:
         display(*objs, include=['text/plain','image/jpeg'])
 
 
 def display_latex(*objs, **kwargs):
     """Display the LaTeX representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw latex data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_latex(obj)
     else:
         display(*objs, include=['text/plain','text/latex'])
 
 
 def display_json(*objs, **kwargs):
     """Display the JSON representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw json data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_json(obj)
     else:
         display(*objs, include=['text/plain','application/json'])
 
 
 def display_javascript(*objs, **kwargs):
     """Display the Javascript representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw javascript data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     """
     raw = kwargs.pop('raw',False)
     if raw:
         for obj in objs:
             publish_javascript(obj)
     else:
         display(*objs, include=['text/plain','application/javascript'])
 
 #-----------------------------------------------------------------------------
 # Smart classes
 #-----------------------------------------------------------------------------
 
 
 class DisplayObject(object):
     """An object that wraps data to be displayed."""
 
     _read_flags = 'r'
 
     def __init__(self, data=None, url=None, filename=None):
         """Create a display object given raw data.
 
         When this object is returned by an expression or passed to the
         display function, it will result in the data being displayed
         in the frontend. The MIME type of the data should match the
         subclasses used, so the Png subclass should be used for 'image/png'
         data. If the data is a URL, the data will first be downloaded
         and then displayed. If
 
         Parameters
         ----------
         data : unicode, str or bytes
             The raw data or a URL to download the data from.
         url : unicode
             A URL to download the data from.
         filename : unicode
             Path to a local file to load the data from.
         """
         if data is not None and data.startswith('http'):
             self.url = data
             self.filename = None
             self.data = None
         else:
             self.data = data
             self.url = url
             self.filename = None if filename is None else unicode(filename)
         self.reload()
 
     def reload(self):
         """Reload the raw data from file or URL."""
         if self.filename is not None:
             with open(self.filename, self._read_flags) as f:
                 self.data = f.read()
         elif self.url is not None:
             try:
                 import urllib2
                 response = urllib2.urlopen(self.url)
                 self.data = response.read()
                 # extract encoding from header, if there is one:
                 encoding = None
                 for sub in response.headers['content-type'].split(';'):
                     sub = sub.strip()
                     if sub.startswith('charset'):
                         encoding = sub.split('=')[-1].strip()
                         break
                 # decode data, if an encoding was specified
                 if encoding:
                     self.data = self.data.decode(encoding, 'replace')
             except:
                 self.data = None
 
 class Pretty(DisplayObject):
 
     def _repr_pretty_(self):
         return self.data
 
 
 class HTML(DisplayObject):
 
     def _repr_html_(self):
         return self.data
 
 
 class Math(DisplayObject):
 
     def _repr_latex_(self):
+        s = self.data.strip('$')
+        return "$$%s$$" % s
+
+
+class Latex(DisplayObject):
+
+    def _repr_latex_(self):
         return self.data
 
 
 class SVG(DisplayObject):
     
     # wrap data in a property, which extracts the <svg> tag, discarding
     # document headers
     _data = None
     
     @property
     def data(self):
         return self._data
     
     @data.setter
     def data(self, svg):
         if svg is None:
             self._data = None
             return
         # parse into dom object
         x = minidom.parseString(svg)
         # get svg tag (should be 1)
         found_svg = x.getElementsByTagName('svg')
         if found_svg:
             svg = found_svg[0].toxml()
         else:
             # fallback on the input, trust the user
             # but this is probably an error.
             pass
         self._data = svg
     
     def _repr_svg_(self):
         return self.data
 
 
 class JSON(DisplayObject):
 
     def _repr_json_(self):
         return self.data
 
 
 class Javascript(DisplayObject):
 
     def _repr_javascript_(self):
         return self.data
 
 
 class Image(DisplayObject):
 
     _read_flags = 'rb'
 
     def __init__(self, data=None, url=None, filename=None, format=u'png', embed=False):
         """Create a display an PNG/JPEG image given raw data.
 
         When this object is returned by an expression or passed to the
         display function, it will result in the image being displayed
         in the frontend.
 
         Parameters
         ----------
         data : unicode, str or bytes
             The raw data or a URL to download the data from.
         url : unicode
             A URL to download the data from.
         filename : unicode
             Path to a local file to load the data from.
         format : unicode
             The format of the image data (png/jpeg/jpg). If a filename or URL is given
             for format will be inferred from the filename extension.
         embed : bool
             Should the image data be embedded in the notebook using a data URI (True)
             or be loaded using an <img> tag. Set this to True if you want the image
             to be viewable later with no internet connection. If a filename is given
             embed is always set to True.
         """
         if filename is not None:
             ext = self._find_ext(filename)
         elif url is not None:
             ext = self._find_ext(url)
         elif data.startswith('http'):
             ext = self._find_ext(data)
         else:
             ext = None
         if ext is not None:
             if ext == u'jpg' or ext == u'jpeg':
                 format = u'jpeg'
             if ext == u'png':
                 format = u'png'
         self.format = unicode(format).lower()
         self.embed = True if filename is not None else embed
         super(Image, self).__init__(data=data, url=url, filename=filename)
 
     def reload(self):
         """Reload the raw data from file or URL."""
         if self.embed:
             super(Image,self).reload()
 
     def _repr_html_(self):
         if not self.embed:
             return u'<img src="%s" />' % self.url
 
     def _repr_png_(self):
         if self.embed and self.format == u'png':
             return self.data
 
     def _repr_jpeg_(self):
         if self.embed and (self.format == u'jpeg' or self.format == u'jpg'):
             return self.data
 
     def _find_ext(self, s):
         return unicode(s.split('.')[-1].lower())
 
 
 def clear_output(stdout=True, stderr=True, other=True):
     """Clear the output of the current cell receiving output.
     
     Optionally, each of stdout/stderr or other non-stream data (e.g. anything
     produced by display()) can be excluded from the clear event.
     
     By default, everything is cleared.
     
     Parameters
     ----------
     stdout : bool [default: True]
         Whether to clear stdout.
     stderr : bool [default: True]
         Whether to clear stderr.
     other : bool [default: True]
         Whether to clear everything else that is not stdout/stderr
         (e.g. figures,images,HTML, any result of display()).
     """
     from IPython.core.interactiveshell import InteractiveShell
     InteractiveShell.instance().display_pub.clear_output(
         stdout=stdout, stderr=stderr, other=other,
     )

IPython/core/formatters.py

@@ -1,620 +1,621 b''
 # -*- coding: utf-8 -*-
 """Display formatters.
 
 
 Authors:
 
 * Robert Kern
 * Brian Granger
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # 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, Integer, Unicode, CUnicode, ObjectName
 from IPython.utils.py3compat import unicode_to_str
 
 
 #-----------------------------------------------------------------------------
 # 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()
     def _formatters_default(self):
         """Activate the default formatters."""
         formatter_classes = [
             PlainTextFormatter,
             HTMLFormatter,
             SVGFormatter,
             PNGFormatter,
             JPEGFormatter,
             LatexFormatter,
             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
         * application/javascript
         * image/png
         * image/jpeg
         * image/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 = Unicode('text/plain')
 
     enabled = Bool(True, config=True)
 
     print_method = ObjectName('__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)
                 # 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 = Unicode('text/plain')
 
     # This subclass ignores this attribute as it always need to return
     # something.
     enabled = Bool(True, config=False)
 
     # Look for a _repr_pretty_ methods to use for pretty printing.
     print_method = ObjectName('_repr_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 = Integer(79, config=True)
 
     # The newline character.
     newline = Unicode('\n', config=True)
 
     # format-string for pprinting floats
     float_format = Unicode('%r')
     # setter for float precision, either int or direct format-string
     float_precision = CUnicode('', 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()
             # self.newline.encode() is a quick fix for issue gh-597. We need to
             # ensure that stream does not get a mix of unicode and bytestrings,
             # or it will cause trouble.
             printer = pretty.RepresentationPrinter(stream, self.verbose,
                 self.max_width, unicode_to_str(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:`_repr_html_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
 
     The return value of this formatter should be a valid HTML snippet that
     could be injected into an existing DOM. It should *not* include the
     ```<html>`` or ```<body>`` tags.
     """
     format_type = Unicode('text/html')
 
     print_method = ObjectName('_repr_html_')
 
 
 class SVGFormatter(BaseFormatter):
     """An SVG formatter.
 
     To define the callables that compute the SVG representation of your
     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.
 
     The return value of this formatter should be valid SVG enclosed in
     ```<svg>``` tags, that could be injected into an existing DOM. It should
     *not* include the ```<html>`` or ```<body>`` tags.
     """
     format_type = Unicode('image/svg+xml')
 
     print_method = ObjectName('_repr_svg_')
 
 
 class PNGFormatter(BaseFormatter):
     """A PNG formatter.
 
     To define the callables that compute the PNG representation of your
     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 return value of this formatter should be raw PNG data, *not*
     base64 encoded.
     """
     format_type = Unicode('image/png')
 
     print_method = ObjectName('_repr_png_')
 
 
 class JPEGFormatter(BaseFormatter):
     """A JPEG formatter.
 
     To define the callables that compute the JPEG representation of your
     objects, define a :meth:`_repr_jpeg_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
 
     The return value of this formatter should be raw JPEG data, *not*
     base64 encoded.
     """
     format_type = Unicode('image/jpeg')
 
     print_method = ObjectName('_repr_jpeg_')
 
 
 class LatexFormatter(BaseFormatter):
     """A LaTeX formatter.
 
     To define the callables that compute the LaTeX representation of your
     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.
 
     The return value of this formatter should be a valid LaTeX equation,
-    enclosed in either ```$``` or ```$$```.
+    enclosed in either ```$```, ```$$``` or another LaTeX equation
+    environment.
     """
     format_type = Unicode('text/latex')
 
     print_method = ObjectName('_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:`_repr_json_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
 
     The return value of this formatter should be a valid JSON string.
     """
     format_type = Unicode('application/json')
 
     print_method = ObjectName('_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.
 
     The return value of this formatter should be valid Javascript code and
     should *not* be enclosed in ```<script>``` tags.
     """
     format_type = Unicode('application/javascript')
 
     print_method = ObjectName('_repr_javascript_')
 
 FormatterABC.register(BaseFormatter)
 FormatterABC.register(PlainTextFormatter)
 FormatterABC.register(HTMLFormatter)
 FormatterABC.register(SVGFormatter)
 FormatterABC.register(PNGFormatter)
 FormatterABC.register(JPEGFormatter)
 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
     * application/javascript
     * image/png
     * image/jpeg
     * image/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
     )
 

docs/examples/notebooks/00_notebook_tour.ipynb

@@ -1,962 +1,999 b''
 {
  "metadata": {
   "name": "00_notebook_tour"
  },
  "nbformat": 3,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "markdown",
      "source": [
       "# A brief tour of the IPython notebook",
       "",
       "This document will give you a brief tour of the capabilities of the IPython notebook.  ",
       "You can view its contents by scrolling around, or execute each cell by typing `Shift-Enter`.",
       "After you conclude this brief high-level tour, you should read the accompanying notebook ",
       "titled `01_notebook_introduction`, which takes a more step-by-step approach to the features of the",
       "system.  ",
       "",
       "The rest of the notebooks in this directory illustrate various other aspects and ",
       "capabilities of the IPython notebook; some of them may require additional libraries to be executed.",
       "",
       "**NOTE:** This notebook *must* be run from its own directory, so you must ``cd``",
       "to this directory and then start the notebook, but do *not* use the ``--notebook-dir``",
       "option to run it from another location.",
       "",
       "The first thing you need to know is that you are still controlling the same old IPython you're used to,",
       "so things like shell aliases and magic commands still work:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "pwd"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "pyout",
        "prompt_number": 1,
        "text": [
         "u'/home/fperez/ipython/ipython/docs/examples/notebooks'"
        ]
       }
      ],
      "prompt_number": 1
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "ls"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "00_notebook_tour.ipynb          python-logo.svg",
         "01_notebook_introduction.ipynb  sympy.ipynb",
         "animation.m4v                   sympy_quantum_computing.ipynb",
         "display_protocol.ipynb          trapezoid_rule.ipynb",
         "formatting.ipynb"
        ]
       }
      ],
      "prompt_number": 2
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "message = 'The IPython notebook is great!'",
       "# note: the echo command does not run on Windows, it's a unix command.",
       "!echo $message"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "The IPython notebook is great!"
        ]
       }
      ],
      "prompt_number": 3
     },
     {
      "cell_type": "markdown",
      "source": [
       "Plots with matplotlib: do *not* execute the next below if you do not have matplotlib installed or didn't start up ",
       "this notebook with the `--pylab` option, as the code will not work."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "x = linspace(0, 3*pi, 500)",
       "plot(x, sin(x**2))",
       "title('A simple chirp');"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "display_data",
        "png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAECCAYAAAASDQdFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAwODbgRD+gYGBgbdCIb0DQwMDLoR/j8U8QHdaUyIsAAAAABJRU5ErkJggg==\n"
       }
      ],
      "prompt_number": 4
     },
     {
      "cell_type": "markdown",
      "source": [
       "You can paste blocks of input with prompt markers, such as those from",
       "[the official Python tutorial](http://docs.python.org/tutorial/interpreter.html#interactive-mode)"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       ">>> the_world_is_flat = 1",
       ">>> if the_world_is_flat:",
       "...     print \"Be careful not to fall off!\""
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "Be careful not to fall off!"
        ]
       }
      ],
      "prompt_number": 5
     },
     {
      "cell_type": "markdown",
      "source": [
       "Errors are shown in informative ways:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "%run non_existent_file"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "stream",
        "stream": "stderr",
        "text": [
         "ERROR: File `non_existent_file.py` not found."
        ]
       }
      ],
      "prompt_number": 6
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "x = 1",
       "y = 4",
       "z = y/(1-x)"
      ],
      "language": "python",
      "outputs": [
       {
        "ename": "ZeroDivisionError",
        "evalue": "integer division or modulo by zero",
        "output_type": "pyerr",
        "traceback": [
         "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
         "\u001b[0;32m/home/fperez/ipython/ipython/docs/examples/notebooks/<ipython-input-7-dc39888fd1d2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
         "\u001b[0;31mZeroDivisionError\u001b[0m: integer division or modulo by zero"
        ]
       }
      ],
      "prompt_number": 7
     },
     {
      "cell_type": "markdown",
      "source": [
       "When IPython needs to display additional information (such as providing details on an object via `x?`",
       "it will automatically invoke a pager at the bottom of the screen:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": true,
      "input": [
       "magic"
      ],
      "language": "python",
      "outputs": [],
      "prompt_number": 8
     },
     {
      "cell_type": "markdown",
      "source": [
       "## Non-blocking output of kernel",
       "",
       "If you execute the next cell, you will see the output arriving as it is generated, not all at the end."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "import time, sys",
       "for i in range(8):",
       "    print i,",
       "    time.sleep(0.5)"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "0 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "1 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "2 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "3 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "4 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "5 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "6 "
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "7"
        ]
       }
      ],
      "prompt_number": 9
     },
     {
      "cell_type": "markdown",
      "source": [
       "## Clean crash and restart",
       "",
       "We call the low-level system libc.time routine with the wrong argument via",
       "ctypes to segfault the Python interpreter:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": true,
      "input": [
       "from ctypes import CDLL",
       "# This will crash a linux system; equivalent calls can be made on Windows or Mac",
       "libc = CDLL(\"libc.so.6\") ",
       "libc.time(-1)  # BOOM!!"
      ],
      "language": "python",
      "outputs": [],
      "prompt_number": "*"
     },
     {
      "cell_type": "markdown",
      "source": [
       "## Markdown cells can contain formatted text and code",
       "",
       "You can *italicize*, **boldface**",
       "",
       "* build",
       "* lists",
       "",
       "and embed code meant for illustration instead of execution in Python:",
       "",
       "    def f(x):",
       "        \"\"\"a docstring\"\"\"",
       "        return x**2",
       "",
       "or other languages:",
       "",
       "    if (i=0; i<n; i++) {",
       "      printf(\"hello %d\\n\", i);",
       "      x += 4;",
       "    }"
      ]
     },
     {
      "cell_type": "markdown",
      "source": [
       "Courtesy of MathJax, you can include mathematical expressions both inline: ",
       "$e^{i\\pi} + 1 = 0$  and displayed:",
       "",
       "$$e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i$$"
      ]
     },
     {
      "cell_type": "markdown",
      "source": [
       "## Rich displays: include anyting a browser can show",
       "",
       "Note that we have an actual protocol for this, see the `display_protocol` notebook for further details.",
       "",
       "### Images"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython.core.display import Image",
       "Image(filename='../../source/_static/logo.png')"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "pyout",
        "png": "iVBORw0KGgoAAAANSUhEUgAAAggAAABDCAYAAAD5/P3lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nHMRRca/E5hVINNIVwI2B56z6/3ExLRI31pXNAAAAAElFTkSuQmCC\n",
        "prompt_number": 1,
        "text": [
         "&lt;IPython.core.display.Image at 0x41d4690&gt;"
        ]
       }
      ],
      "prompt_number": 1
     },
     {
      "cell_type": "markdown",
      "source": [
       "An image can also be displayed from raw data or a url"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "Image('http://python.org/images/python-logo.gif')"
      ],
      "language": "python",
      "outputs": [
       {
        "html": [
         "<img src=\"http://python.org/images/python-logo.gif\" />"
        ],
        "output_type": "pyout",
        "prompt_number": 2,
        "text": [
         "&lt;IPython.core.display.Image at 0x41d4550&gt;"
        ]
       }
      ],
      "prompt_number": 2
     },
     {
      "cell_type": "markdown",
      "source": [
       "SVG images are also supported out of the box (since modern browsers do a good job of rendering them):"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython.core.display import SVG",
       "SVG(filename='python-logo.svg')"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "pyout",
        "prompt_number": 3,
        "svg": [
         "<svg height=\"115.02pt\" id=\"svg2\" inkscape:version=\"0.43\" sodipodi:docbase=\"/home/sdeibel\" sodipodi:docname=\"logo-python-generic.svg\" sodipodi:version=\"0.32\" version=\"1.0\" width=\"388.84pt\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:cc=\"http://web.resource.org/cc/\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:sodipodi=\"http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd\" xmlns:svg=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">",
         "  <metadata id=\"metadata2193\">",
         "    <rdf:RDF>",
         "      <cc:Work rdf:about=\"\">",
         "        <dc:format>image/svg+xml</dc:format>",
         "        <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>",
         "      </cc:Work>",
         "    </rdf:RDF>",
         "  </metadata>",
         "  <sodipodi:namedview bordercolor=\"#666666\" borderopacity=\"1.0\" id=\"base\" inkscape:current-layer=\"svg2\" inkscape:cx=\"243.02499\" inkscape:cy=\"71.887497\" inkscape:pageopacity=\"0.0\" inkscape:pageshadow=\"2\" inkscape:window-height=\"543\" inkscape:window-width=\"791\" inkscape:window-x=\"0\" inkscape:window-y=\"0\" inkscape:zoom=\"1.4340089\" pagecolor=\"#ffffff\"/>",
         "  <defs id=\"defs4\">",
         "    <linearGradient id=\"linearGradient2795\">",
         "      <stop id=\"stop2797\" offset=\"0\" style=\"stop-color:#b8b8b8;stop-opacity:0.49803922\"/>",
         "      <stop id=\"stop2799\" offset=\"1\" style=\"stop-color:#7f7f7f;stop-opacity:0\"/>",
         "    </linearGradient>",
         "    <linearGradient id=\"linearGradient2787\">",
         "      <stop id=\"stop2789\" offset=\"0\" style=\"stop-color:#7f7f7f;stop-opacity:0.5\"/>",
         "      <stop id=\"stop2791\" offset=\"1\" style=\"stop-color:#7f7f7f;stop-opacity:0\"/>",
         "    </linearGradient>",
         "    <linearGradient id=\"linearGradient3676\">",
         "      <stop id=\"stop3678\" offset=\"0\" style=\"stop-color:#b2b2b2;stop-opacity:0.5\"/>",
         "      <stop id=\"stop3680\" offset=\"1\" style=\"stop-color:#b3b3b3;stop-opacity:0\"/>",
         "    </linearGradient>",
         "    <linearGradient id=\"linearGradient3236\">",
         "      <stop id=\"stop3244\" offset=\"0\" style=\"stop-color:#f4f4f4;stop-opacity:1\"/>",
         "      <stop id=\"stop3240\" offset=\"1\" style=\"stop-color:#ffffff;stop-opacity:1\"/>",
         "    </linearGradient>",
         "    <linearGradient id=\"linearGradient4671\">",
         "      <stop id=\"stop4673\" offset=\"0\" style=\"stop-color:#ffd43b;stop-opacity:1\"/>",
         "      <stop id=\"stop4675\" offset=\"1\" style=\"stop-color:#ffe873;stop-opacity:1\"/>",
         "    </linearGradient>",
         "    <linearGradient id=\"linearGradient4689\">",
         "      <stop id=\"stop4691\" offset=\"0\" style=\"stop-color:#5a9fd4;stop-opacity:1\"/>",
         "      <stop id=\"stop4693\" offset=\"1\" style=\"stop-color:#306998;stop-opacity:1\"/>",
         "    </linearGradient>",
         "    <linearGradient gradientTransform=\"translate(100.2702,99.61116)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2987\" x1=\"224.23996\" x2=\"-65.308502\" xlink:href=\"#linearGradient4671\" y1=\"144.75717\" y2=\"144.75717\"/>",
         "    <linearGradient gradientTransform=\"translate(100.2702,99.61116)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2990\" x1=\"172.94208\" x2=\"26.670298\" xlink:href=\"#linearGradient4689\" y1=\"77.475983\" y2=\"76.313133\"/>",
         "    <linearGradient gradientTransform=\"translate(100.2702,99.61116)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2587\" x1=\"172.94208\" x2=\"26.670298\" xlink:href=\"#linearGradient4689\" y1=\"77.475983\" y2=\"76.313133\"/>",
         "    <linearGradient gradientTransform=\"translate(100.2702,99.61116)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2589\" x1=\"224.23996\" x2=\"-65.308502\" xlink:href=\"#linearGradient4671\" y1=\"144.75717\" y2=\"144.75717\"/>",
         "    <linearGradient gradientTransform=\"translate(100.2702,99.61116)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2248\" x1=\"172.94208\" x2=\"26.670298\" xlink:href=\"#linearGradient4689\" y1=\"77.475983\" y2=\"76.313133\"/>",
         "    <linearGradient gradientTransform=\"translate(100.2702,99.61116)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2250\" x1=\"224.23996\" x2=\"-65.308502\" xlink:href=\"#linearGradient4671\" y1=\"144.75717\" y2=\"144.75717\"/>",
         "    <linearGradient gradientTransform=\"matrix(0.562541,0,0,0.567972,-11.5974,-7.60954)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2255\" x1=\"224.23996\" x2=\"-65.308502\" xlink:href=\"#linearGradient4671\" y1=\"144.75717\" y2=\"144.75717\"/>",
         "    <linearGradient gradientTransform=\"matrix(0.562541,0,0,0.567972,-11.5974,-7.60954)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient2258\" x1=\"172.94208\" x2=\"26.670298\" xlink:href=\"#linearGradient4689\" y1=\"76.176224\" y2=\"76.313133\"/>",
         "    <radialGradient cx=\"61.518883\" cy=\"132.28575\" fx=\"61.518883\" fy=\"132.28575\" gradientTransform=\"matrix(1,0,0,0.177966,0,108.7434)\" gradientUnits=\"userSpaceOnUse\" id=\"radialGradient2801\" r=\"29.036913\" xlink:href=\"#linearGradient2795\"/>",
         "    <linearGradient gradientTransform=\"matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient1475\" x1=\"150.96111\" x2=\"112.03144\" xlink:href=\"#linearGradient4671\" y1=\"192.35176\" y2=\"137.27299\"/>",
         "    <linearGradient gradientTransform=\"matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)\" gradientUnits=\"userSpaceOnUse\" id=\"linearGradient1478\" x1=\"26.648937\" x2=\"135.66525\" xlink:href=\"#linearGradient4689\" y1=\"20.603781\" y2=\"114.39767\"/>",
         "    <radialGradient cx=\"61.518883\" cy=\"132.28575\" fx=\"61.518883\" fy=\"132.28575\" gradientTransform=\"matrix(2.382716e-8,-0.296405,1.43676,4.683673e-7,-128.544,150.5202)\" gradientUnits=\"userSpaceOnUse\" id=\"radialGradient1480\" r=\"29.036913\" xlink:href=\"#linearGradient2795\"/>",
         "  </defs>",
         "  <g id=\"g2303\">",
         "    <path d=\"M 184.61344,61.929363 C 184.61344,47.367213 180.46118,39.891193 172.15666,39.481813 C 168.85239,39.325863 165.62611,39.852203 162.48754,41.070593 C 159.98254,41.967323 158.2963,42.854313 157.40931,43.751043 L 157.40931,78.509163 C 162.72147,81.842673 167.43907,83.392453 171.55234,83.148783 C 180.25649,82.573703 184.61344,75.507063 184.61344,61.929363 z M 194.85763,62.533683 C 194.85763,69.931723 193.12265,76.072393 189.63319,80.955683 C 185.7441,86.482283 180.35396,89.328433 173.46277,89.484393 C 168.26757,89.650093 162.91642,88.022323 157.40931,84.610843 L 157.40931,116.20116 L 148.50047,113.02361 L 148.50047,42.903043 C 149.96253,41.109583 151.84372,39.569543 154.12454,38.263433 C 159.42696,35.173603 165.86978,33.584823 173.45302,33.506853 L 173.57973,33.633563 C 180.50991,33.545833 185.85132,36.391993 189.60395,42.162263 C 193.10315,47.454933 194.85763,54.238913 194.85763,62.533683 z \" id=\"path46\" style=\"fill:#646464;fill-opacity:1\"/>",
         "    <path d=\"M 249.30487,83.265743 C 249.30487,93.188283 248.31067,100.05998 246.32227,103.88084 C 244.32411,107.7017 240.52275,110.75254 234.90842,113.02361 C 230.35653,114.81707 225.43425,115.79178 220.15133,115.95748 L 218.67952,110.34316 C 224.05016,109.61213 227.83204,108.88109 230.02513,108.15006 C 234.34309,106.688 237.30621,104.44617 238.93397,101.44406 C 240.24008,98.997543 240.88339,94.328693 240.88339,87.418003 L 240.88339,85.098203 C 234.79146,87.866373 228.40711,89.240713 221.73036,89.240713 C 217.34417,89.240713 213.47457,87.866373 210.14107,85.098203 C 206.39818,82.086343 204.52674,78.265483 204.52674,73.635623 L 204.52674,36.557693 L 213.43558,33.506853 L 213.43558,70.828453 C 213.43558,74.815013 214.7222,77.885353 217.29543,80.039463 C 219.86866,82.193563 223.20217,83.226753 227.2862,83.148783 C 231.37023,83.061053 235.74667,81.482023 240.39603,78.392203 L 240.39603,34.851953 L 249.30487,34.851953 L 249.30487,83.265743 z \" id=\"path48\" style=\"fill:#646464;fill-opacity:1\"/>",
         "    <path d=\"M 284.08249,88.997033 C 283.02006,89.084753 282.04535,89.123743 281.14862,89.123743 C 276.10937,89.123743 272.18129,87.924853 269.37413,85.517323 C 266.57671,83.109793 265.17314,79.786033 265.17314,75.546053 L 265.17314,40.456523 L 259.07146,40.456523 L 259.07146,34.851953 L 265.17314,34.851953 L 265.17314,19.968143 L 274.07223,16.800333 L 274.07223,34.851953 L 284.08249,34.851953 L 284.08249,40.456523 L 274.07223,40.456523 L 274.07223,75.302373 C 274.07223,78.645623 274.96896,81.014163 276.76243,82.398253 C 278.30247,83.538663 280.74899,84.191723 284.08249,84.357423 L 284.08249,88.997033 z \" id=\"path50\" style=\"fill:#646464;fill-opacity:1\"/>",
         "    <path d=\"M 338.02288,88.266003 L 329.11404,88.266003 L 329.11404,53.878273 C 329.11404,50.379063 328.29528,47.367213 326.66753,44.852463 C 324.78634,42.006313 322.17411,40.583233 318.82112,40.583233 C 314.73708,40.583233 309.6296,42.737343 303.4987,47.045563 L 303.4987,88.266003 L 294.58985,88.266003 L 294.58985,6.0687929 L 303.4987,3.2616329 L 303.4987,40.700203 C 309.191,36.557693 315.40963,34.481563 322.16436,34.481563 C 326.88196,34.481563 330.70282,36.070333 333.62694,39.238143 C 336.56082,42.405943 338.02288,46.353513 338.02288,51.071103 L 338.02288,88.266003 L 338.02288,88.266003 z \" id=\"path52\" style=\"fill:#646464;fill-opacity:1\"/>",
         "    <path d=\"M 385.37424,60.525783 C 385.37424,54.930953 384.31182,50.310833 382.19669,46.655673 C 379.68195,42.201253 375.77337,39.852203 370.49044,39.608523 C 360.72386,40.173863 355.85032,47.172273 355.85032,60.584263 C 355.85032,66.734683 356.86401,71.871393 358.91089,75.994413 C 361.52312,81.248093 365.44145,83.840823 370.66589,83.753103 C 380.47146,83.675123 385.37424,75.935933 385.37424,60.525783 z M 395.13109,60.584263 C 395.13109,68.547643 393.09395,75.175663 389.02941,80.468333 C 384.5555,86.394563 378.37584,89.367423 370.49044,89.367423 C 362.67328,89.367423 356.58135,86.394563 352.18541,80.468333 C 348.19885,75.175663 346.21044,68.547643 346.21044,60.584263 C 346.21044,53.098503 348.36455,46.801883 352.67276,41.674913 C 357.22466,36.236033 363.20937,33.506853 370.6074,33.506853 C 378.00545,33.506853 384.02914,36.236033 388.66877,41.674913 C 392.97697,46.801883 395.13109,53.098503 395.13109,60.584263 z \" id=\"path54\" style=\"fill:#646464;fill-opacity:1\"/>",
         "    <path d=\"M 446.20583,88.266003 L 437.29699,88.266003 L 437.29699,51.928853 C 437.29699,47.942293 436.0981,44.832973 433.70032,42.591133 C 431.30253,40.359053 428.10549,39.277123 424.11893,39.364853 C 419.8887,39.442833 415.86314,40.826913 412.04229,43.507363 L 412.04229,88.266003 L 403.13345,88.266003 L 403.13345,42.405943 C 408.26042,38.672813 412.97801,36.236033 417.28621,35.095623 C 421.35076,34.033193 424.93769,33.506853 428.02752,33.506853 C 430.14264,33.506853 432.13104,33.711543 434.00248,34.120913 C 437.50169,34.929923 440.34783,36.430973 442.54093,38.633823 C 444.98744,41.070593 446.20583,43.994723 446.20583,47.415943 L 446.20583,88.266003 z \" id=\"path56\" style=\"fill:#646464;fill-opacity:1\"/>",
         "    <path d=\"M 60.510156,6.3979729 C 55.926503,6.4192712 51.549217,6.8101906 47.697656,7.4917229 C 36.35144,9.4962267 34.291407,13.691825 34.291406,21.429223 L 34.291406,31.647973 L 61.103906,31.647973 L 61.103906,35.054223 L 34.291406,35.054223 L 24.228906,35.054223 C 16.436447,35.054223 9.6131468,39.73794 7.4789058,48.647973 C 5.0170858,58.860939 4.9078907,65.233996 7.4789058,75.897973 C 9.3848341,83.835825 13.936449,89.491721 21.728906,89.491723 L 30.947656,89.491723 L 30.947656,77.241723 C 30.947656,68.391821 38.6048,60.585475 47.697656,60.585473 L 74.478906,60.585473 C 81.933857,60.585473 87.885159,54.447309 87.885156,46.960473 L 87.885156,21.429223 C 87.885156,14.162884 81.755176,8.7044455 74.478906,7.4917229 C 69.872919,6.7249976 65.093809,6.3766746 60.510156,6.3979729 z M 46.010156,14.616723 C 48.779703,14.616723 51.041406,16.915369 51.041406,19.741723 C 51.041404,22.558059 48.779703,24.835473 46.010156,24.835473 C 43.23068,24.835472 40.978906,22.558058 40.978906,19.741723 C 40.978905,16.91537 43.23068,14.616723 46.010156,14.616723 z \" id=\"path1948\" style=\"fill:url(#linearGradient1478);fill-opacity:1\"/>",
         "    <path d=\"M 91.228906,35.054223 L 91.228906,46.960473 C 91.228906,56.191228 83.403011,63.960472 74.478906,63.960473 L 47.697656,63.960473 C 40.361823,63.960473 34.291407,70.238956 34.291406,77.585473 L 34.291406,103.11672 C 34.291406,110.38306 40.609994,114.65704 47.697656,116.74172 C 56.184987,119.23733 64.323893,119.68835 74.478906,116.74172 C 81.229061,114.78733 87.885159,110.85411 87.885156,103.11672 L 87.885156,92.897973 L 61.103906,92.897973 L 61.103906,89.491723 L 87.885156,89.491723 L 101.29141,89.491723 C 109.08387,89.491723 111.98766,84.056315 114.69765,75.897973 C 117.49698,67.499087 117.37787,59.422197 114.69765,48.647973 C 112.77187,40.890532 109.09378,35.054223 101.29141,35.054223 L 91.228906,35.054223 z M 76.166406,99.710473 C 78.945884,99.710476 81.197656,101.98789 81.197656,104.80422 C 81.197654,107.63057 78.945881,109.92922 76.166406,109.92922 C 73.396856,109.92922 71.135156,107.63057 71.135156,104.80422 C 71.135158,101.98789 73.396853,99.710473 76.166406,99.710473 z \" id=\"path1950\" style=\"fill:url(#linearGradient1475);fill-opacity:1\"/>",
         "    <path d=\"M 463.5544,26.909383 L 465.11635,26.909383 L 465.11635,17.113143 L 468.81648,17.113143 L 468.81648,15.945483 L 459.85427,15.945483 L 459.85427,17.113143 L 463.5544,17.113143 L 463.5544,26.909383 M 470.20142,26.909383 L 471.53589,26.909383 L 471.53589,17.962353 L 474.4323,26.908259 L 475.91799,26.908259 L 478.93615,17.992683 L 478.93615,26.909383 L 480.39194,26.909383 L 480.39194,15.945483 L 478.46605,15.945483 L 475.16774,25.33834 L 472.35477,15.945483 L 470.20142,15.945483 L 470.20142,26.909383\" id=\"text3004\" style=\"font-size:15.16445827px;font-style:normal;font-weight:normal;line-height:125%;fill:#646464;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Bitstream Vera Sans\"/>",
         "    <path d=\"M 110.46717 132.28575 A 48.948284 8.6066771 0 1 1  12.570599,132.28575 A 48.948284 8.6066771 0 1 1  110.46717 132.28575 z\" id=\"path1894\" style=\"opacity:0.44382019;fill:url(#radialGradient1480);fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:20;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1\" transform=\"matrix(0.73406,0,0,0.809524,16.24958,27.00935)\"/>",
         "  </g>",
         "</svg>"
        ],
        "text": [
         "&lt;IPython.core.display.SVG at 0x41d4910&gt;"
        ]
       }
      ],
      "prompt_number": 3
     },
     {
      "cell_type": "markdown",
      "source": [
       "### Video"
      ]
     },
     {
      "cell_type": "markdown",
      "source": [
       "And more exotic objects can also be displayed, as long as their representation supports ",
       "the IPython display protocol.",
       "",
       "For example, videos hosted externally on YouTube are easy to load (and writing a similar wrapper for other",
       "hosted content is trivial):"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython.lib.display import YouTubeVideo",
       "# a talk about IPython at Sage Days at U. Washington, Seattle.",
       "# Video credit: William Stein.",
       "YouTubeVideo('1j_HxD4iLn8')"
      ],
      "language": "python",
      "outputs": [
       {
        "html": [
         "",
         "            <iframe",
         "                width=\"400\"",
         "                height=\"300\"",
         "                src=\"http://www.youtube.com/embed/1j_HxD4iLn8\"",
         "                frameborder=\"0\"",
         "                allowfullscreen",
         "            ></iframe>",
         "        "
        ],
        "output_type": "pyout",
        "prompt_number": 4,
        "text": [
         "&lt;IPython.lib.display.YouTubeVideo at 0x41d4310&gt;"
        ]
       }
      ],
      "prompt_number": 4
     },
     {
      "cell_type": "markdown",
      "source": [
       "Using the nascent video capabilities of modern browsers, you may also be able to display local",
       "videos.  At the moment this doesn't work very well in all browsers, so it may or may not work for you;",
       "we will continue testing this and looking for ways to make it more robust.  ",
       "",
       "The following cell loads a local file called  `animation.m4v`, encodes the raw video as base64 for http",
       "transport, and uses the HTML5 video tag to load it. On Chrome 15 it works correctly, displaying a control",
       "bar at the bottom with a play/pause button and a location slider."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython.core.display import HTML",
       "video = open(\"animation.m4v\", \"rb\").read()",
       "video_encoded = video.encode(\"base64\")",
       "video_tag = '<video controls alt=\"test\" src=\"data:video/x-m4v;base64,{0}\">'.format(video_encoded)",
       "HTML(data=video_tag)"
      ],
      "language": "python",
      "outputs": [
       {
        "html": [
         "<video controls alt=\"test\" src=\"data:video/x-m4v;base64,AAAAHGZ0eXBNNFYgAAACAGlzb21pc28yYXZjMQAAAAhmcmVlAAAqiW1kYXQAAAKMBgX//4jcRem9",
         "5tlIt5Ys2CDZI+7veDI2NCAtIGNvcmUgMTE4IC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENv",
         "cHlsZWZ0IDIwMDMtMjAxMSAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9w",
         "dGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1o",
         "ZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2",
         "IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0",
         "X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTEgc2xpY2VkX3RocmVhZHM9MCBu",
         "cj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9p",
         "bnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEg",
         "d2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yNSBz",
         "Y2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9",
         "MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89",
         "MS40MCBhcT0xOjEuMDAAgAAACqVliIQAV/0TAAI/3gU2tIW7KawwaCmQGTGHKmuYAAADACBcshU+",
         "yICkgAA14AHowiEeT6ei7v7h3Hu0i2fpUBLGBIkbCMP3Vfz+9BVGCDXnw9Uv5o3iN030tb7eq6rs",
         "EEhHs2azbdTiE9Csz5Zm6SiUWRdmB43hbD5i6syATuODUJd7LM3d9cbFpc7zFlu5y3vUmNGd6urp",
         "vKKT9iyleIyTuR1sVS431DhevGfkUllVeIznYUe2USoMW1tufETjyRdmGldN6eNlhAOsGAH4z+Hk",
         "rwKecPPU7Q5T4gDAIxj9hW84jVExMTSTHxkPTq1I4OotgUxURCGTsw60k/ezPNmNg38j1bqaGmPc",
         "ruDKEIBDsK5qEytFB90Q68s0h2wmlf2KXd5bleBefiK+/p47ZsyUO4IdlW25rRy+HLjt6wQXfYee",
         "3IkiQOoOK+U7u/lxcl78zfxwIoEMjUUSKNZjkp8clnmecDDJ3Kz+viF7bPklk7N6QRyizAKPIIpn",
         "NJUuMWQmqeL2Or6cr4D0/0tOym+4tficxmhuEONKUtO2pPn3hRjMllkd12tXp70fLTfxy0dwB70M",
         "L9iLEcItHb7zVupHlP5RxdvecpREw+OsIPr9KWilIesNE19jgIbT+TkiRBjOoKvUuwcQnKg7fOTH",
         "VoLvnKuAfea+oujEdm1Rwd2tEOnkF+ZC11WaNQsiNR/eJ9EnUXjXDYGfhB+Oe7qj8nYTT+eOXg1c",
         "uJNgLXEs4vOheWEjQOqfIWMQc3DmTof5s0ksBmUQ3PQ+UHPxZSnmOEZB+j6xT3wbm7HGzDjWtSg1",
         "SjTxd1EiJ8xA4SIxxR8WIKLg+TwFxJNS7Laxq7Uglu3AkXe82P1JCdJX5PsbFbxuDbuJgakzRcTw",
         "MLLSKCiizS/eCW0uJed/lev9yb80kKlVET4S219cn/zhkpeDV83cHYOr+sJQKDRk/Wh2c7fsuxfx",
         "aEH/6reSmvFDsAnXAyPXliJ3G4VG3OkEM5K5WyGGrBizZbTrdGsBnzj5VSGGOJdCKuRrUluw/8es",
         "2vYRPs9BcTqAqvHk9M52SSIf+1T6L53EZP8VbtXB+G29CMW4xVCK/B/YDjaNmqMwJ61dapugjnWJ",
         "fqeXlGGa3Ch3aA7gi30T8PucNRBjLK3lF67ZDDvkWXRQXd+VMnKWHkBbCkQ/F/fMuNpHO3C00Y2p",
         "ljna1qImBhVMvPe0F7Qx7G/YyxLRzhyUU8e23HGzp0agtNJRbydbrPV+TqJMSifJMNcZIf8wkdnC",
         "3/xdpcXnLf2Ye3Kbd0o7utciTG+q5h6WTEk+PaNbXLLA0YyZ2VnLTcyV1QTS76aNCbV9Q1/OQ7QU",
         "81Gg0hPa9aSiscGary6jLVwDQaik4zLsi7jPqgPVdup7pwx7uJDqRCVcVi5QoZFp/GHdex5sJTF6",
         "9A6sja69/NLkFIWNSIeRcuGahXpF+wZeYIrqJv975s1TKYKAvp1WtzgtgWNkcbzCtROqf8rPtlAI",
         "xkX8GLcEo9zfExyfimeXQ64qfFxEy0IMy2Hsxau9fSMqUnIjntuVVjCQtBL+94gx1RZLndE6wROV",
         "Tq/wHwHrQzo9QL9cpPqPFJjiZ/NGZIFuudS+wsBFe6Hu8Oitf5zToLqLdtU4Smwh4ne3JsiT9lOz",
         "N+4PPw3VSx9l5FppVwdKUWELw1dYpCOppyVWlJ3YQ8H4FQQM8EcYMG9N3Bxu79y1J1ikuvuhMmLQ",
         "lehLTbguhbix74hd1VIQC8EjHmOZSSWbssulYwPbr6FF49tifk6PymJvulR9/u+2585HkRfbxveG",
         "eWCz0ix1pIVfaNpESKmtLy/0mcbMg9hYDz2werz9oe0lT2BiMV6uAin6RaQcT8Vk9MPctfwae+gk",
         "vtnZA/sOBk8MbpylaHqc0KIVHhhLFMNnkOFiucjtGo/JWTa/F6g8wWeow5ZuIJUORaYHWqegZbTg",
         "M9dCsYYsfZGjjVMuSlDIvpYvIvFFooGPC7Ye2Jfawmq4Ut7EL/nv/dyAd2HRc5msmUhzeu/XpX3r",
         "VlzRmf9/Qan8Dbve3QfW1Ym0o5J/KAc3z1VBho7JBr5PgCL68RiD9jZHN0VvsT4gzsEjNlW3D91U",
         "y4RduaodBFoNTzXwlfUYULBzdiTbH75l/UmVMC4TKeTWhNzw2UezaqeGd8at3WSY7W/VR3+hvZHD",
         "pkIjgKuNNH0DsCRa/Kk56XQoHIyvvUH/eNekNvziReqS4qgLnXUT4BRGt2BOtCifI6+X/DGHUOmW",
         "lX7TN5b4pw5U7jwfwshtbhGZM49T8JMk15Mzrc7tM6J11TYxb5R3mQhZ8TZumJ0bMJXPM69HFyih",
         "r5dJSEJMycxJVUh6NTQALUOoRTHIOwE+FpWI6feTv1SiZ0YpYe5DbkYJJbN7zAHbAKw25XvqR2mA",
         "jQmOlsfX/tK8DPjP/8h5/xgAF4EUbj1tOnQCBQL8jk9vHtfsXncsprww4Z+P/Z/UrKifuFyEpBWN",
         "8kLpF7yywE2iYdDruV9+/qKR8rC9ozNKyqQNIwtxrzYkWpE5t8K7gG4JFnrHona/Rp8dOX6VW41+",
         "jb5LB1LEtE8MwjLp3RCUOq/+6yLzaOEgBTqzvEjDeFpg/u9DMHMr4/2TOchfjg7dl+uQ6Gsx+4Ia",
         "9W7vivG95027p25eKL0nHvx/OqmAQEZYJL/JO58lOj0zPdJxrQ5dZksjMISzVZNn7DsxqE3zgBBu",
         "Nzk50R8lTK3U8P12QiOAQYSTeGlYlkvfeofrfO1AitEj02m9aUkxTFd1ZZJoLQT2d3zEU5PmE4lx",
         "MVfL5ttNnIbqfcIU2RJKNWqdw77xfjfrNc/eNpRKPZ/6z50LzBprgjzBHRfKgSWWkDxHrX0aTbgw",
         "QFwd51+PoUWH4DkQg26uGslF5Hn3hB58+fkeLTosTANOIBNAeFZtTc4PIaLHw759zae7scY55xcT",
         "abzlilYIftst2RZ6ntsRC3zFxduCKvL6wLfYT+TiIWJn5P7sTwZwXuSzXY+9Q3xMZ5o4Xcpz6vD9",
         "FtTjzS69iefEYt4pXiDrZUo4ePGiLeoIFIwYB/v6GXdmG5VLLk+eKbOc9AmsX2zmvqtcvDRGQbzu",
         "gXbH/kTH/lkNPBTmqN3ZJODUEXVohPEJ6th0xna0EVleB73Q3eNvaVUvhlJbjs3D/T17FRCebN7A",
         "OXvzzbLE/I5kNfEmJcv4dxtIeo2uQ/z9ohSpiZzbDj1u40nJRyJxUK60wEv0nA9f/NuJ6/PEyU0b",
         "kK16z2KH12k3Lc4+1f5fawIzkK2qJRB4wnj8VHhUW9mbJhs9vgfFmU3xrXSShY67Ygb+gYNPxxtn",
         "4K/9eTSwIA9fv/nR33lA2lZoXALRUTmOZIl3R0gAM5h6oX1y1thIyqViBK95VZc8Pvy7G3O90M9S",
         "4zkpyFQ36jrMazvMveMA4d39fvoaC7p90quiJfjI4yrl+ECVkCJL5MxRSa+iVcIL7Xbl0jVaGhZI",
         "cMYmcGOBbLzhJgloM1x1zFnnj3ggJRFAM8yNnXxhavk+mA18JC+y3lqGsp6vPReRxGlGHMou17L4",
         "It070LzkoeCzarpv8Apw59smdS5KN9qVN1WgeL7OSN8BHg94ubCvS7DW6H3/PbtRB62jFLsBhUV5",
         "YqCIbIN5VZ81AAACpUGaIWxFfwAru8x8uT3FuOjrAeSWXmAWqq9jCNGE+N5AOv//9//xjk4uBAcA",
         "DN96c97AVGmzRtnWwPsgcCbLrVdQJgbKp4QSmPwQnVhv0hXyBjeFWWlcvx70urEN3FK6/lvk2tQe",
         "ZgbtlbzXluvTfnSj/Ctz7vZ+O1FjhDzzdpL7uLzewzCIW5VWLAEKUVuS2J6wNk6MR7UblcEd4EtO",
         "Y+R4/qJgfojCsfRvA0oC5dc41Vd0erZbSkrmPTjLCn815bxlchUJMS8gQD5hJNwoKHvNLNwn7XKu",
         "TtYIhH2wVNZvDWgzCjlPeQajnrcMsb6bZYJvNJU8HuGHvm50r7VG8qifEwmuyegAZXojh5Ul5Vvj",
         "DW7kSAZyw8a7I6mHY3FZHd+OA3V4JZMbNliI3Tj1L6+MKTmilVialmyZagRtEMeKRdtxUPd3vVEt",
         "rOBVIVYWdgAGA7HmZiHQUQNxLkWxbLyWVlrh5EM0Do2NdbclHxxArz90d+MSVeUOIXQ/4V9quq8C",
         "8qVflo1gPtPMkjO2/UrdOYqhY404ReObOu/fdp4hAEDq6jhy64vOeT7XUK/Onq0rXTldtA6kvgQa",
         "Jg+mgYSR9hfXtMbOUSLgLj/RmBSO8aAMHuJJZqf1tCM5pZ9eYUsrHmy+/z2NGalon0//uF6+33bQ",
         "zT/RLRfBbYTjy9QrJqHLlw46lggWPGkHuPKSqk/CB7U4pNPXUbR0DdcJy9Db00wCzVzxVc6h7jfC",
         "FgiL2Y0HVqd6bgIaVUqn/gJCEyCDVplnzebv0gg3XwMJAGu639lHu7rEvxTp1smIYjWp9R5L4Ssp",
         "VvS07Nb+Smk1FgsMp1K3EMUT8X2Fty4VG54/Ec6bE8tNVw4/QV1VzBw7Px2/2eEhhUS+FMfbHAlD",
         "28x00jRgAAACW0GaQjwhkymEVwArOUkEOhoFqiELtH8wgecFLiUq6WqmwAP7iGEwbYzfnHacfqUN",
         "XAfD+CGR2ap0lAHL25ipuYtd5j2O0PU/MpaWPG/n2y5OkfTzaOpotaR5tWjN55B2XblVVqsFfBC/",
         "mvsiPvCBWUHFChacdY5whj5mP5rqQ0dqLJCsWjrs4TWnIbL2V/Iwfj3hwI35jfo1JkTOeR+8GhOd",
         "ma9rgiKWafCbQyhYMTDmVdvhND60Flm97EDSTjF0OC+0gD9b8Yn4tNeHipCa/aWyt0n79bMmjfcj",
         "ntBCPjrcB5ecRTpfGHbEHy1IRj2cjkGXKC+VYoYJXBp4rd4cMd8ygLCk5nBSd8/cTaKNRjdBscOe",
         "TXG6QEjSxj9/2pVwx9DMRVtWQR0BSaAcQcZ8W2KPSaeRC4QwmNMu2xx25CSyrDiq2rFSK/JJtmvo",
         "IjAKq0ciEXoOgw+Ke+Ylb7ULKCS3k1p/613UNRp450uSq5b7CAHo7S0b7fBMLfNmwSjRYEhLlo0H",
         "UaRe/I+IX2Z6XdZH9Hty/399ZA1PwZGC6EfvUJIf7CBeaxv7cu6IT2/s0zPRGthpvXpYw6A7P4Ww",
         "z5C4V98KnIUNUanadqabKP6eXWhvbvcQHxAjiOOiKZgXZplZW2g+B2NNyJSLiR+g48DqvWR6t9S2",
         "aGfFjdOW1Gi6oTtZ1d4p5XIslAr8mryeZ6+htSSQe4AcfVt7k+V6mOthBCYtr/LEU4ZHtl0mW987",
         "6PK8mRFAaT8DJOUFVz1lPfzRApuPggkkyq+UMvyfKTUbCk7/DpfX8Y4s4QAAAg9BmmNJ4Q8mUwIr",
         "/wAsWUPjZw3ksgRsxZ6n4fQjprPbkj2aUh30y0bZJnLmiXnWskvOGnCPwBnG9dEhatwX3hoxk7BN",
         "yG+wQ4emZUpcVzcWl2T9nKQB1euucuZWHTg7TCtM/iHyfPO2vbmGsfzs70b/egIbywUH4y4BQSL1",
         "nWc1SmpHm2zHMBcUjYLDZ5gL5vdfxn0V8FFw66G88c/LN4I5icUa7xf4fcSBKywU0ajbp1P+aJYj",
         "BgWT6Ggu0MDLDNl54tfqd42lKosQtM1aif4WXAZFP5Ww3vrQ1rH9+utSYxqZd6N6gGtNbSNMcVia",
         "Kn5LcnjsbBi3T3EmGqshEbcme8VHKwR3kSfBOAprrIsv6K8R+X6az+MD23rWka/2v64m1qM69D7X",
         "a+Kcs/n0KLCJdTilyaGadopLeaAn3eYvWTeHcucMM1Fp1KgHD1tiFeO6HvobLkZlRximsA3/7Mio",
         "hYklLIcJrZL22BH+6W9d6kZsYIsej9RM681nU6mWNjepBAfAfTbrGRrVB/h2DxC5B8YyRjgSIzQj",
         "NYrse0rzChqbrsLl7mQ7W+1bsNKze5//9ZIa8rSsF+BXh/vgoRTDkPW/ws95B7VPCZEFChfX0icw",
         "+tpcpN/q7NY87tUn4vESdSiMMlyhKklMjQu/G51J69ZRQLs2oUO6YfoJFqliy4qCFCrf8SZE9Fc6",
         "DcCagAAAAodBmoRJ4Q8mUwIr/wArPWF/KOw78THwadfPqhJO0CnmR/M74/XYZLqVYKlNcEaYauf+",
         "vrRUDJPmu75sMKy2Y+Bnslc/iAISSyWtw/h/3CF8fE5ZrbrwSNst+MSyCoNWP+8imtoX2eyojpdC",
         "k8YP5K+cbK4SJPCkZXbYqSXYk7hO8AdSemBHgXKWiZ+UOr802aJo+98ZOIjX9hWL9bo31Gqx7cy4",
         "ZG+W/ar/WGlzDa1xPWnPRsEdrIcZlEVGV/jGmbirkxw1lyUYoqj8Vv7Bxube9XPQlBkXOV6Lc1LT",
         "2IzNq0V7WwVhF0kA6yxfAsFxc9krNEH8vGGntTWI608ovjatXc/CKKXw7AjJSftlTcLI0hIIGXbR",
         "Ur0NCYNp7M4cVd/n73Rjetnixz4SAKpcz/P47UsijZG7T3SxzK2D79WS42aEalc12hQwCZ01LfmF",
         "/H2mmGEvOzPBie1D0YT7Jh19vxa4Dd3SQ1FrDfmSUpvv4DjbYcZ2PrPpFpWtMjWqHBeoyMiZf6RP",
         "3EfYR6z9jsVNIIHxM0bzzBQF8eeYkPgDySydxPXv9Izo+QUY94N8kWi16fI6eZSDc1G0Yo0L91jc",
         "RQuDMGGS7B2zuf/0GbJyRhUO48UbMrqnILMrbQg1LF00Q3pH9nbGEK/RRQpRN3T/J/4IZQjwW2Ft",
         "2ipWGztg1Jn9I4DmffKS60QC+JQcyakdVON6zDcKttIKlqeTcmAi4xzmo4QXa2dRKleS+fs3EtTd",
         "BBtony2wK9T2Imj+NCziOSEL7Q7VuIU8kclUHrJJsSneFcxGRgIgGGUEQM8/pklwTOqab7mMmJeR",
         "iaBrjJDEnDpkR4Vz3qXxgyn4/5x24FuTMNVPwQAAAhtBmqVJ4Q8mUwIr/wApcLwPT0/Xh9UdWqWX",
         "Is8Wbj5K1hivmN6qIQnq+aolcegdlM/63MbHsdC6xYZC1e/Q8UjQCt9N/Ejqwms8DzeWv2qxskel",
         "iZH0kt1QWkErWSEodq7V0ZNksctLkMGWayX33gBT368EehfIeGDolBZoqIbJfb4nqcfU+ev4OzVv",
         "9zVqWyLck315GFmXxQKIM8pICQc8Q5es34LH1+DmnMnW8kQpVGrztQcDXhjCU3F0fOgoSsXSVWCj",
         "c6XKqGbCwQDfJUxCfXfIT6YmQoPpVp1mpGy1wQypXus9z0bScDpyDu23hViYDntdj1O45ea0znKZ",
         "kj1+tLHbBtqAGJ1WTcbGlF6Vya6hQhEsiiZUIC2fRxIj8/wEXCICIbr0gZ/m6gcOhE10tenvE7iy",
         "+BKY81wLWrnzos3S6FWxYtmCRes+LLhNGOKWRuQo6SyePH2OZ90xZm8oA1MuTe3V59euVNxjAt0F",
         "LkAc9TEiFhP/8CB+gA8mF+A8h1U01f4DVX55GzCH51jHI2xUS0L9GtsHoBxLPLK/NNel8zcnwG4X",
         "+UusfcfEb5hh+ffnXteCE9vRGbs2n9wYW0xA3ZicklfadmWKUtMiHYBfkMSULWnkBQr4CXxjpYOs",
         "6ygeEoA5+5B0B1SZObgZ42wWqddyyYE0NfwQAl75tfdJGqOa7OMHwBYNeatJaJK0zT2+bFaw2qWC",
         "WwAAAitBmsZJ4Q8mUwIr/wAstkdsayRXchoFk703izqzduZ5WsyXriI9cfUdMUWvm0iGHwYIrUuj",
         "vz3Yjou+JLwv9df2kt7MJo8u+3P5CjEKbwlz4vkE5AHTAbgXn3+Xc/MMJLgW5cm7iX3KiGNnBpbp",
         "hhwJRlb3u91NRDr0d1IR2up/z7lKxE7XPAPFe0siPMYVlIqWNSn5KqLABPeuxxbOsvMEb27/nH1L",
         "UVM8I2F95c1I3Lv1SpkhZXjs1JsmS9X7gsoTxkXyShGC2+zRJSGUbhCPo/q1XSFMHQyMWJ79FKPQ",
         "SL/RpVsacN2bYwdKo4TFBw1SsKq/L1iOmqMI+4Gxnbbjojdk0ek0JIcDb4bHv1czxchF7FX1Ym8H",
         "6IpPuE8CeNKjzQ1a1wqhEu+wl1N0x3Y37ZryCCKJRkxj0FT7bOoH3L38/yMUuh/v3aCmxY4eCkyk",
         "b2p6ZrYMFE044anM/nMjmbErMibfRFuCz58Io1rBlF7JfkIz0R2/5vjUMVskcdbX2mm7DntncOsW",
         "DIdg/XVmgsC9CzVzUyq4VsS/sk97lJggcddpWLNw/29egz8iLyzWHOAXCvl2fTIPkviYAOQXfVhZ",
         "UQdxsyJUNFMTiALrZCmoQLMp2LmDbfbW8JQriDeR3fVz6P1sjT8C2yEDvzkCn7sh0aTBK+sx7BKH",
         "1nb4320+caQepQj4TCJtCeNXjdrVcNEnjvwlcRJwFT1pT+Y7HREbHnT71XYNh4EAAAGEQZrnSeEP",
         "JlMCK/8AKIjxcI58rm/ML255fOJW1zbznFna7lfgMQrka7OTPPsvVAV4EJXye/Uxiu9dlftmRypJ",
         "qfDot3xwDe8lX/qAVf6pBkSlUsaLyBYtww/SUSa1bGl1JvrJCN7FXCCXbLd5R4PoYlPiDIm/DQH2",
         "puO0StIWmrR77Isc/J1pRvdu5+mQa/n0SEHUeM2KkoRzCznfD9zaaRO7BDtvC9SYIT0uYZxrwTjx",
         "Q7N7UERTrYG0P+vRLAhxkfohFIYl3HXyjPOvnlbUFP2oiiy6nkUFuaIyQcJawJv3GU8k4ObcKsC1",
         "cNDXjSpsyQRrxLFaCCjke4mikyt7vs0iN0bnrNWv9HXruG9zOFEOer1ggIFTsT1Eos5CXRkgja5H",
         "N4QUM6MhWpc5du/HgBIH8ANFcoo2kJpqcadw9r/0qk25X91MQSDJQiH8Hny2dQhqR+LFWEawiW75",
         "3SJhn0ngZcv/mPj3mwcHv1SL9ErBqAjm4JGiDetPKYtFwANYY11OyQAAAVdBmwhJ4Q8mUwIr/wAr",
         "Ox5HV2505jRePGgMxptW4PGIHEszV1xGZS+flSkF+aq30AaqO7u6XK9jJsuWXTfYCRQTn1bZfFQ2",
         "2DbO5DXAxK/TUmbQleCflFzeS6/czxkL4PJ8AwOs2U+oehekgCZC8gZyHHaQSaKbNJ46gTjNsLy8",
         "4ACQ5uNt11TPuCPqPTuh+schdw9S+/lU/6m+EyaqGZ49wDFPiBFBYXglQQBjyP9k/rqq0xL7SiLj",
         "pe4riYg8SFUuUtOzPdWHyvxnI7Ug/0VLPGAAhgMISUnqe01d5QFf36yHpwMAHexjAZFIGQHAFaut",
         "uMuEw6HzUZVzNdeHYxvEYOGkTo007bLwbuf/nxzrywGOxlRTYJLRdYI0mk0SdN3+LeTv1RIJwv21",
         "+e9rT5iFOTCgzeQoekEWXLYz0X8YLq5bVCtijP7/T7w1Ck71j0aqfrEn6wtIAAABNUGbKUnhDyZT",
         "Aiv/ACcySi7VBgOid6qZNXvhh/JsllHkMLLq0yNbQTqv/Wk2EBoSKICZwFwAD0WRzhvvReCGirep",
         "1Fe4bxjm49/UR+OYrXRmHR18T0C83AUVeBk7KvDZmb/eHzuzEN4yfXucr/NWFJl+USVMY4r4UQ9C",
         "ayrfEY9v6AQ6mzAdLy2UMfFxrRJ99g/Rfl8qx+m4jIZNjlrTaThzJ/3OpVmAliDfxVyg8+CVIlI3",
         "1IykiwQrXcebgajG+av8XU1SfyAG5ibvwbtdSAxkGBcJWL387V+uTdY56w3KN2vBtoQpVKD2zb3y",
         "azIcATZ02upwIytNcM/rpaLCdMb1myWcikE25agzLhDhOS+4zwjYz2DnW6VY0gFBAPsphhsUMnau",
         "VVdUVHzCTSdvzEve/H8q4AAAAVdBm0pJ4Q8mUwIr/wAo+x5XKuiN1am7SkJKSMonFZDPU3f5XFcD",
         "QSs0FLVq2idfsKwuIkt1mxIq8NgMHpzofTnDHqs/WedvAmhBgL0N5azdQa5MNKG2rJ4IAvGQY/uF",
         "m3jKQAKzvhSS01gO1oIfizF817z9IShS4QK2WT0PeFPELqLSpED8eNOpVTR96vmwpk/WBKRVJdTQ",
         "JzjiCQ5pgEwjtvk7KqoS0+lwXSbvIrXkYm8DignEts3DLNoLHrPjXlQmbIop76JZSyJEtB+91GrL",
         "wo6Km5GeebyA2E6qGL3xSkpppej/ruoFprSKrH60UMbrq/SK7eCo+1QFoySPQmqDFsMGiQFqvtld",
         "5BXDYdVI4yRaoyN7Y7wi83HRC6eVazuHU9OtIY3xJJApBWq1aJOsYwc38aTC3ee863Aa/4n9Lk4D",
         "AtyFYHNZjB5m2e2vk8G2Gny9YFlBAAABQEGba0nhDyZTAiv/ACoZSZQfHxhfQxEqOBQrP+L3Dmgv",
         "HSJQtB1iVkcLTxm+vagLHBLG91OGnopwrr7gT/loDypIhoRxjcwAAOeg/jN4WBbXzCJtnWGGllUC",
         "SdtUZQzKOSp9iM4yX18C6jrY4Sq6R9PUV/lEGNveJR4gw4FMve7110XdEPL1O2VTdHvdqeANyaq0",
         "nLdEmtXnrzvdrFlBaUvmaR4EdlkqGkvkZKWJej8Vq+msbKa7JdbxjwZtRufiyGfD/NVqMgSrYRzw",
         "9z/a8Zwbr+9+19CxlWD5bCuAEfPmjY6kZJE2L/CQI6+tnCBTXOmWZtZMBoCLGOf7G2uAC3+kFlbo",
         "h9as5WCkO6+iqXq29dyhKnsHInorRYsPlgxIXyU1Om/Kyhj1DJV0Am9WJK3Dln0zNUH0q6ZTOnZc",
         "FD36AAABYkGbjEnhDyZTAiv/ACcwdIOLRFfoGK2ZkKsvgMwG0m0qsY0vMLPSzefc+ebp/aztyF7M",
         "lsBz/fBeNtxFBcsKgR4pf65GvdfOMHah0ltZ918sMDmXUEZMeRHy/xpnWpTLeGz6uTs/7MATPmU5",
         "BgHbT/DkD8QeaZnFAzidyFCXDz2l/jaKhEdgqipbB2pH0+fQ039r05z9axxEWGmaLQjg6x9+po1o",
         "24yhkVO7m03YwWmPyCgy8cOwrvRyJkXJpRN4m8ZBS1zwY80HeN/VyMQQJSMwsTo7R1XMerSFuyx0",
         "nz+8qOuhiqykc2ohCCsXia/+kIKbJ5Vs+cbWtvkqBKIDSfU7FhAd3GjcY/xar0EVmi6wWFTugAog",
         "R3I7mTrQDdlTAqYgqO7Gn5NMXQVHu2i1zhFSdo9GjMbeGnbkJwsFbQ2XkoKRIDpuW7AewC9AEBt0",
         "Ox/Ah6dGXfXO1jl8pEApj2RFmgAAAPlBm61J4Q8mUwIr/wAlR+eW/VZ7bSrmwwMA62G05DZ7p/5F",
         "UugsSsQdonUq6abtbU5hjFr+I1lPgoiV5c3CkTQZS+K5zivdo+Ti2P4K90xXANp8dSMAu85uJIOC",
         "Qn2TXbEnNDifLB+3V84ht5tj4lvTaZx317BcliV8D5v2zZQW8RO1mUbuJEBItst8E7hfE+ZXj7tf",
         "DxNZPTvtpFyUv0fH1cTg1pr2VLy0d0zQLiA58dg+GkRvR1/hs2LyifBgHcj6eTWz0vsypVn9iPXR",
         "H/unJ6i8cfFL69NO24tQ9QQB+nDFhoP2cRhkAvhHwn56n5PppBD/oxni2f8AAAE9QZvOSeEPJlMC",
         "K/8AJjAXVGf+Kj2XNJnFeKC/gr7dJDTC2ngpd4WeAHlg04GuJKnn9hAmiECxxo9qM1IYMRiB85t6",
         "gALnlm9sRqGmioyzAm18RJndc9Ah8RlpGzr+44a6ntRaPx0cIwNIWAA8buL2JP00dmfjNqEiAlCa",
         "8OdV8FQxjp1vDXsGcAGF3Qbd62KEpkimeI3wH2nuXpbDHm8/ZKOR49s5ifUCkxCoJpfp43aC0lTz",
         "h2NXpcfVw6h0QnK8G60R4ZAxOxaJB7c0nn8ixXSU2JVY24EtGMF53nxJnHfzUheewUfBOGYSxeo8",
         "oK7oUCqX4rztzDwoc2QywNqQUJUkFrqIN+sb5ecYvX24Zujn+ZzTW6UDAF3R6WdNyJyRAremgC8s",
         "pSflTqygQNGfHyGkfIEEJJaFo/pBCBkAAAEWQZvvSeEPJlMCK/8AKI41fuekXG59Knbw4Y6YJrit",
         "sh9VtQgc3QKvVmxrzzo7f4aXn8N74eyP4b2lV1Z2Q+rohxps7EHTkOY9jLdqxI3MXe7je4g2qepz",
         "71+hY+jYdX+9LO0kA0Zg3NfyAlIRX7k6c/YHAZNtNaGZgTBMqiPgmEjiJH9Luk7shbgr+srfwiYw",
         "BX9rdS3fQNNFwcT8orQC+F60LAY9+GbFo2Sw3Ld4Tw9jq9yJtrY8RtHAdzytyek/mv2+j2TbTvAQ",
         "KbbCYtdC8E/KtR4V5ZTSScr5Wb63vmbw7UpddEXYvl55pARyyvMxWNSh3Li4GF8Jk5JBi5B5ASQw",
         "xCMYpX5hkAMc+d8tl2bT+IEvUTsAAAElQZoQSeEPJlMCK/8AJIAzFZs00JJ0yfm8CZiew4xWdArL",
         "klEvBVXo/+ukPLu3XP9HFOfsme3T6BJEKmPPgZw/Lxnraq6Sl2kLVW19YU1qmqgfv+80LkZaWU5g",
         "RAH4hqyo3bFYcbuY2SC3IW5Wm69gtYyAXOdbAYSEHA16fvCeRQjHEsxKVndJdrRAlrGHsKgUBQ3U",
         "p/ZXIy1vkdFOfKSjpuZnswkuqr8NZI5tJ/dnBSErBTNWPaNwWV7nNomC0EYVGo+geGBhLXzaLw0U",
         "AOCYGjiPc3803BDw1GLoLIXjrIFJxwRfBNIAXYZAglu30oYzhpAfRWSprkeULMWYJTlWvbUQ5CNe",
         "wSZssuDWIRAc3w8AcFaywwn+YSGhtR8VI1OGjYkfBbcAAAD8QZoxSeEPJlMCK/8AJdokjCUETRw/",
         "nciVPtaZQSBP/VxAQSITASEzlJBl9Na1r0DJhLOz279+KQLtl/xHZ8vAKc528mTMTqtWs4sFbeVg",
         "HWyBpHcHEtgTzjIqEinp/MPuUXF5poo8YLSSMFn9Ozx2FbU5/Kh9A39oN9NHQflVxV1NA6yT/84H",
         "HyfMtfdSMS8KTvAEE2lDs14VQayNs5ctjXboQT7xMBf5OLj6thhPvgaDrFB2o/PV9ouK147lruWT",
         "P2mkoA9oDIMYW1pcBx4yyV/t9GOPZ3aXneMUb2fFmUCX43BjXfUDMaa4GO2/Ankj3UEQwDxA7ZlN",
         "UQK2AAAA4UGaUknhDyZTAiv/ACJHv33I08bkhybYiJ/JiiheW5zMPBu4n5CxGr3frhE7TkLh0vPk",
         "tM8m/AhaDiJisdk5QXNe/4WmxEDSAyaVi4eUVu0iHT2ly/KNTGqiORqA2oKpTjh84nYbrpXwnGv9",
         "SOf/34Z06xN6Yo3t35UZrP8nlcs/63GtnEmnUwVZHBYfPM6bs5M5AeBfAQ/9mIqu7vnEst+5O2wp",
         "PjzdItjwGCZ2ApHVjGnYYFomlA9nm6AXnxNIWHIsDgxCk3zx+6QbXipu/CWLG1Wf0WIbt4C0JPVl",
         "3TEb0QAAAMlBmnNJ4Q8mUwIr/wAVV64OfTKmlktYOqZHH1W1DhPy/X/6sD4T6hRdzfOgNtTOX2Ic",
         "kRJHshfBQVkJIzns079io6kpJFCcS3VD4zrWCn/dNaGV0kWTpFBRuusfn8F0C0R/EhsQeyTsdZft",
         "EkLGb5tq+nrir3vfmeb7rjmWJRXkIrTEKu8pIuAd+4FBGp8ARgGe80Jqpp//s1433HqBFqXsIFJT",
         "mU8j/toF9HyueI1Ea4uvsQ6NANGcYCbOAKCmbNiwABMCFaiUTMAAAAPSbW9vdgAAAGxtdmhkAAAA",
         "AHwlsIB8JbCAAAAD6AAAAyAAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAA",
         "AAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAv10cmFrAAAAXHRraGQA",
         "AAAPfCWwgHwlsIAAAAABAAAAAAAAAyAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAB",
         "AAAAAAAAAAAAAAAAAABAAAAAAY4AAAGGAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAAMgAAAA",
         "AgABAAAAAAJ1bWRpYQAAACBtZGhkAAAAAHwlsIB8JbCAAAAAGQAAABRVxAAAAAAALWhkbHIAAAAA",
         "AAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAACIG1pbmYAAAAUdm1oZAAAAAEAAAAA",
         "AAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAAAeBzdGJsAAAAtHN0c2QA",
         "AAAAAAAAAQAAAKRhdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAY4BhgBIAAAASAAAAAAAAAAB",
         "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAMmF2Y0MBZAAV/+EAGWdkABWs",
         "2UGQz6mhAAADAAEAAAMAMg8WLZYBAAZo6+PLIsAAAAAcdXVpZGtoQPJfJE/FujmlG88DI/MAAAAA",
         "AAAAGHN0dHMAAAAAAAAAAQAAABQAAAABAAAAFHN0c3MAAAAAAAAAAQAAAAEAAAAYY3R0cwAAAAAA",
         "AAABAAAAFAAAAAIAAAAcc3RzYwAAAAAAAAABAAAAAQAAAAEAAAABAAAAZHN0c3oAAAAAAAAAAAAA",
         "ABQAAA05AAACqQAAAl8AAAITAAACiwAAAh8AAAIvAAABiAAAAVsAAAE5AAABWwAAAUQAAAFmAAAA",
         "/QAAAUEAAAEaAAABKQAAAQAAAADlAAAAzQAAAGBzdGNvAAAAAAAAABQAAAAsAAANZQAAEA4AABJt",
         "AAAUgAAAFwsAABkqAAAbWQAAHOEAAB48AAAfdQAAINAAACIUAAAjegAAJHcAACW4AAAm0gAAJ/sA",
         "ACj7AAAp4AAAAGF1ZHRhAAAAWW1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAA",
         "AAAAAAAALGlsc3QAAAAkqXRvbwAAABxkYXRhAAAAAQAAAABMYXZmNTIuMTExLjA=",
         "\">"
        ],
        "output_type": "pyout",
        "prompt_number": 5,
        "text": [
         "&lt;IPython.core.display.HTML at 0x423a550&gt;"
        ]
       }
      ],
      "prompt_number": 5
     },
     {
      "cell_type": "markdown",
      "source": [
       "## Local Files",
       "",
       "The above examples embed images and video from the notebook filesystem in the output",
       "areas of code cells.  It is also possible to request these files directly in markdown cells",
       "if they reside in the notebook directory via relative urls prefixed with `files/`:",
       "",
       "    files/[subdirectory/]<filename>",
       "",
       "",
       "For example, in the example notebook folder, we have the Python logo, addressed as:",
       "",
       "    <img src=\"files/python-logo.svg\" />",
       "",
       "<img src=\"/files/python-logo.svg\" />",
       "",
       "and a video with the HTML5 video tag:",
       "",
       "    <video controls src=\"files/animation.m4v\" />",
       "",
       "<video controls src=\"/files/animation.m4v\" />",
       "",
       "These do not embed the data into the notebook file,",
       "and require that the files exist when you are viewing the notebook.",
       "",
       "### Security of local files",
       "",
       "Note that this means that the IPython notebook server also acts as a generic file server",
       "for files inside the same tree as your notebooks.  Access is not granted outside the",
       "notebook folder so you have strict control over what files are visible, but for this",
       "reason it is highly recommended that you do not run the notebook server with a notebook",
       "directory at a high level in your filesystem (e.g. your home directory).",
       "",
       "When you run the notebook in a password-protected manner, local file access is restricted",
       "to authenticated users unless read-only views are active."
      ]
     },
     {
      "cell_type": "markdown",
      "source": [
       "### External sites",
       "",
       "You can even embed an entire page from another site in an iframe; for example this is today's Wikipedia",
       "page for mobile users:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "HTML('<iframe src=http://en.mobile.wikipedia.org/?useformat=mobile width=700 height=350>')"
      ],
      "language": "python",
      "outputs": [
       {
        "html": [
         "<iframe src=http://en.mobile.wikipedia.org/?useformat=mobile width=700 height=350>"
        ],
        "output_type": "pyout",
        "prompt_number": 6,
        "text": [
         "&lt;IPython.core.display.HTML at 0x41d4710&gt;"
        ]
       }
      ],
      "prompt_number": 6
     },
     {
      "cell_type": "markdown",
      "source": [
       "### Mathematics",
       "",
       "And we also support the display of mathematical expressions typeset in LaTeX, which is rendered",
       "in the browser thanks to the [MathJax library](http://mathjax.org).  ",
       "",
       "Note that this is *different* from the above examples.  Above we were typing mathematical expressions",
       "in Markdown cells (along with normal text) and letting the browser render them; now we are displaying",
       "the output of a Python computation as a LaTeX expression wrapped by the `Math()` object so the browser",
-      "renders it:"
+      "renders it.  The `Math` object will add the needed LaTeX delimiters (`$$`) if they are not provided:"
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "from IPython.core.display import Math",
-      "Math(r'$F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$')"
+      "Math(r'F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx')"
      ],
      "language": "python",
      "outputs": [
       {
        "latex": [
-        "$F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$"
+        "$$F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$$"
        ],
        "output_type": "pyout",
-       "prompt_number": 8,
+       "prompt_number": 1,
        "text": [
-        "&lt;IPython.core.display.Math at 0x45840d0&gt;"
+        "<IPython.core.display.Math object at 0x10ad35e90>"
        ]
       }
      ],
-     "prompt_number": 8
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "markdown",
+     "source": [
+      "With the `Latex` class, you have to include the delimiters yourself.  This allows you to use other LaTeX modes such as `eqnarray`:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "from IPython.core.display import Latex",
+      "Latex(r\"\"\"\\begin{eqnarray}",
+      "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\",
+      "\\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\",
+      "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\",
+      "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 ",
+      "\\end{eqnarray}\"\"\")"
+     ],
+     "language": "python",
+     "outputs": [
+      {
+       "latex": [
+        "\\begin{eqnarray}",
+        "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\   \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\",
+        "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\",
+        "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 ",
+        "\\end{eqnarray}"
+       ],
+       "output_type": "pyout",
+       "prompt_number": 5,
+       "text": [
+        "<IPython.core.display.Latex object at 0x109a38790>"
+       ]
+      }
+     ],
+     "prompt_number": 5
     },
     {
      "cell_type": "markdown",
      "source": [
       "# Loading external codes",
       "* Drag and drop a ``.py`` in the dashboard",
       "* Use ``%loadpy`` with any local or remote url: [the Matplotlib Gallery!](http://matplotlib.sourceforge.net/gallery.html)",
       "",
       "In this notebook we've kept the output saved so you can see the result, but you should run the next",
       "cell yourself (with an active internet connection)."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": true,
      "input": [
       "%loadpy http://matplotlib.sourceforge.net/mpl_examples/pylab_examples/integral_demo.py"
      ],
      "language": "python",
      "outputs": [],
      "prompt_number": 8
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "#!/usr/bin/env python",
       "",
       "# implement the example graphs/integral from pyx",
       "from pylab import *",
       "from matplotlib.patches import Polygon",
       "",
       "def func(x):",
       "    return (x-3)*(x-5)*(x-7)+85",
       "",
       "ax = subplot(111)",
       "",
       "a, b = 2, 9 # integral area",
       "x = arange(0, 10, 0.01)",
       "y = func(x)",
       "plot(x, y, linewidth=1)",
       "",
       "# make the shaded region",
       "ix = arange(a, b, 0.01)",
       "iy = func(ix)",
       "verts = [(a,0)] + zip(ix,iy) + [(b,0)]",
       "poly = Polygon(verts, facecolor='0.8', edgecolor='k')",
       "ax.add_patch(poly)",
       "",
       "text(0.5 * (a + b), 30,",
       "     r\"$\\int_a^b f(x)\\mathrm{d}x$\", horizontalalignment='center',",
       "     fontsize=20)",
       "",
       "axis([0,10, 0, 180])",
       "figtext(0.9, 0.05, 'x')",
       "figtext(0.1, 0.9, 'y')",
       "ax.set_xticks((a,b))",
       "ax.set_xticklabels(('a','b'))",
       "ax.set_yticks([])",
       "show()"
      ],
      "language": "python",
      "outputs": [
       {
        "output_type": "display_data",
        "png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADzCAYAAAAl6cWdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n"
       }
      ],
      "prompt_number": 9
     },
     {
      "cell_type": "code",
      "collapsed": true,
      "input": [],
      "language": "python",
      "outputs": []
     }
    ]
   }
  ]
 }
  No newline at end of file