Various docs fixes

IPython/parallel/client/remotefunction.py

@@ -1,282 +1,285 b''
 """Remote Functions and decorators for Views.
 
 Authors:
 
 * Brian Granger
 * Min RK
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-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 __future__ import division
 
 import sys
 import warnings
 
 from IPython.external.decorator import decorator
 from IPython.testing.skipdoctest import skip_doctest
 
 from . import map as Map
 from .asyncresult import AsyncMapResult
 
 #-----------------------------------------------------------------------------
 # Functions and Decorators
 #-----------------------------------------------------------------------------
 
 @skip_doctest
 def remote(view, block=None, **flags):
     """Turn a function into a remote function.
 
     This method can be used for map:
 
     In [1]: @remote(view,block=True)
        ...: def func(a):
        ...:    pass
     """
 
     def remote_function(f):
         return RemoteFunction(view, f, block=block, **flags)
     return remote_function
 
 @skip_doctest
 def parallel(view, dist='b', block=None, ordered=True, **flags):
     """Turn a function into a parallel remote function.
 
     This method can be used for map:
 
     In [1]: @parallel(view, block=True)
        ...: def func(a):
        ...:    pass
     """
 
     def parallel_function(f):
         return ParallelFunction(view, f, dist=dist, block=block, ordered=ordered, **flags)
     return parallel_function
 
 def getname(f):
     """Get the name of an object.
     
     For use in case of callables that are not functions, and
     thus may not have __name__ defined.
     
     Order: f.__name__ >  f.name > str(f)
     """
     try:
         return f.__name__
     except:
         pass
     try:
         return f.name
     except:
         pass
     
     return str(f)
 
 @decorator
 def sync_view_results(f, self, *args, **kwargs):
     """sync relevant results from self.client to our results attribute.
     
     This is a clone of view.sync_results, but for remote functions
     """
     view = self.view
     if view._in_sync_results:
         return f(self, *args, **kwargs)
     view._in_sync_results = True
     try:
         ret = f(self, *args, **kwargs)
     finally:
         view._in_sync_results = False
         view._sync_results()
     return ret
     
 #--------------------------------------------------------------------------
 # Classes
 #--------------------------------------------------------------------------
 
 class RemoteFunction(object):
     """Turn an existing function into a remote function.
 
     Parameters
     ----------
 
     view : View instance
         The view to be used for execution
     f : callable
         The function to be wrapped into a remote function
     block : bool [default: None]
         Whether to wait for results or not.  The default behavior is
         to use the current `block` attribute of `view`
 
     **flags : remaining kwargs are passed to View.temp_flags
     """
 
     view = None # the remote connection
     func = None # the wrapped function
     block = None # whether to block
     flags = None # dict of extra kwargs for temp_flags
 
     def __init__(self, view, f, block=None, **flags):
         self.view = view
         self.func = f
         self.block=block
         self.flags=flags
 
     def __call__(self, *args, **kwargs):
         block = self.view.block if self.block is None else self.block
         with self.view.temp_flags(block=block, **self.flags):
             return self.view.apply(self.func, *args, **kwargs)
 
 
 class ParallelFunction(RemoteFunction):
     """Class for mapping a function to sequences.
 
     This will distribute the sequences according the a mapper, and call
     the function on each sub-sequence.  If called via map, then the function
     will be called once on each element, rather that each sub-sequence.
 
     Parameters
     ----------
 
     view : View instance
         The view to be used for execution
     f : callable
         The function to be wrapped into a remote function
     dist : str [default: 'b']
         The key for which mapObject to use to distribute sequences
         options are:
+
           * 'b' : use contiguous chunks in order
           * 'r' : use round-robin striping
+
     block : bool [default: None]
         Whether to wait for results or not.  The default behavior is
         to use the current `block` attribute of `view`
     chunksize : int or None
         The size of chunk to use when breaking up sequences in a load-balanced manner
     ordered : bool [default: True]
         Whether the result should be kept in order. If False,
         results become available as they arrive, regardless of submission order.
-    **flags : remaining kwargs are passed to View.temp_flags
+    **flags
+        remaining kwargs are passed to View.temp_flags
     """
 
     chunksize = None
     ordered = None
     mapObject = None
     _mapping = False
 
     def __init__(self, view, f, dist='b', block=None, chunksize=None, ordered=True, **flags):
         super(ParallelFunction, self).__init__(view, f, block=block, **flags)
         self.chunksize = chunksize
         self.ordered = ordered
 
         mapClass = Map.dists[dist]
         self.mapObject = mapClass()
     
     @sync_view_results
     def __call__(self, *sequences):
         client = self.view.client
         
         lens = []
         maxlen = minlen = -1
         for i, seq in enumerate(sequences):
             try:
                 n = len(seq)
             except Exception:
                 seq = list(seq)
                 if isinstance(sequences, tuple):
                     # can't alter a tuple
                     sequences = list(sequences)
                 sequences[i] = seq
                 n = len(seq)
             if n > maxlen:
                 maxlen = n
             if minlen == -1 or n < minlen:
                 minlen = n
             lens.append(n)
         
         # check that the length of sequences match
         if not self._mapping and minlen != maxlen:
             msg = 'all sequences must have equal length, but have %s' % lens
             raise ValueError(msg)
         
         balanced = 'Balanced' in self.view.__class__.__name__
         if balanced:
             if self.chunksize:
                 nparts = maxlen // self.chunksize + int(maxlen % self.chunksize > 0)
             else:
                 nparts = maxlen
             targets = [None]*nparts
         else:
             if self.chunksize:
                 warnings.warn("`chunksize` is ignored unless load balancing", UserWarning)
             # multiplexed:
             targets = self.view.targets
             # 'all' is lazily evaluated at execution time, which is now:
             if targets == 'all':
                 targets = client._build_targets(targets)[1]
             elif isinstance(targets, int):
                 # single-engine view, targets must be iterable
                 targets = [targets]
             nparts = len(targets)
 
         msg_ids = []
         for index, t in enumerate(targets):
             args = []
             for seq in sequences:
                 part = self.mapObject.getPartition(seq, index, nparts, maxlen)
                 args.append(part)
 
             if sum([len(arg) for arg in args]) == 0:
                 continue
 
             if self._mapping:
                 if sys.version_info[0] >= 3:
                     f = lambda f, *sequences: list(map(f, *sequences))
                 else:
                     f = map
                 args = [self.func] + args
             else:
                 f=self.func
 
             view = self.view if balanced else client[t]
             with view.temp_flags(block=False, **self.flags):
                 ar = view.apply(f, *args)
 
             msg_ids.extend(ar.msg_ids)
 
         r = AsyncMapResult(self.view.client, msg_ids, self.mapObject,
                             fname=getname(self.func),
                             ordered=self.ordered
                         )
 
         if self.block:
             try:
                 return r.get()
             except KeyboardInterrupt:
                 return r
         else:
             return r
 
     def map(self, *sequences):
         """call a function on each element of one or more sequence(s) remotely.
         This should behave very much like the builtin map, but return an AsyncMapResult
         if self.block is False.
         
         That means it can take generators (will be cast to lists locally),
         and mismatched sequence lengths will be padded with None.
         """
         # set _mapping as a flag for use inside self.__call__
         self._mapping = True
         try:
             ret = self(*sequences)
         finally:
             self._mapping = False
         return ret
 
 __all__ = ['remote', 'parallel', 'RemoteFunction', 'ParallelFunction']

IPython/parallel/client/view.py

@@ -1,1119 +1,1114 b''
 """Views of remote engines.
 
 Authors:
 
 * Min RK
 """
 from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-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
 #-----------------------------------------------------------------------------
 
 import imp
 import sys
 import warnings
 from contextlib import contextmanager
 from types import ModuleType
 
 import zmq
 
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.traitlets import (
     HasTraits, Any, Bool, List, Dict, Set, Instance, CFloat, Integer
 )
 from IPython.external.decorator import decorator
 
 from IPython.parallel import util
 from IPython.parallel.controller.dependency import Dependency, dependent
 from IPython.utils.py3compat import string_types, iteritems, PY3
 
 from . import map as Map
 from .asyncresult import AsyncResult, AsyncMapResult
 from .remotefunction import ParallelFunction, parallel, remote, getname
 
 #-----------------------------------------------------------------------------
 # Decorators
 #-----------------------------------------------------------------------------
 
 @decorator
 def save_ids(f, self, *args, **kwargs):
     """Keep our history and outstanding attributes up to date after a method call."""
     n_previous = len(self.client.history)
     try:
         ret = f(self, *args, **kwargs)
     finally:
         nmsgs = len(self.client.history) - n_previous
         msg_ids = self.client.history[-nmsgs:]
         self.history.extend(msg_ids)
         self.outstanding.update(msg_ids)
     return ret
 
 @decorator
 def sync_results(f, self, *args, **kwargs):
     """sync relevant results from self.client to our results attribute."""
     if self._in_sync_results:
         return f(self, *args, **kwargs)
     self._in_sync_results = True
     try:
         ret = f(self, *args, **kwargs)
     finally:
         self._in_sync_results = False
         self._sync_results()
     return ret
 
 @decorator
 def spin_after(f, self, *args, **kwargs):
     """call spin after the method."""
     ret = f(self, *args, **kwargs)
     self.spin()
     return ret
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 @skip_doctest
 class View(HasTraits):
     """Base View class for more convenint apply(f,*args,**kwargs) syntax via attributes.
 
     Don't use this class, use subclasses.
 
     Methods
     -------
 
     spin
         flushes incoming results and registration state changes
         control methods spin, and requesting `ids` also ensures up to date
 
     wait
         wait on one or more msg_ids
 
     execution methods
         apply
         legacy: execute, run
 
     data movement
         push, pull, scatter, gather
 
     query methods
         get_result, queue_status, purge_results, result_status
 
     control methods
         abort, shutdown
 
     """
     # flags
     block=Bool(False)
     track=Bool(True)
     targets = Any()
 
     history=List()
     outstanding = Set()
     results = Dict()
     client = Instance('IPython.parallel.Client')
 
     _socket = Instance('zmq.Socket')
     _flag_names = List(['targets', 'block', 'track'])
     _in_sync_results = Bool(False)
     _targets = Any()
     _idents = Any()
 
     def __init__(self, client=None, socket=None, **flags):
         super(View, self).__init__(client=client, _socket=socket)
         self.results = client.results
         self.block = client.block
 
         self.set_flags(**flags)
 
         assert not self.__class__ is View, "Don't use base View objects, use subclasses"
 
     def __repr__(self):
         strtargets = str(self.targets)
         if len(strtargets) > 16:
             strtargets = strtargets[:12]+'...]'
         return "<%s %s>"%(self.__class__.__name__, strtargets)
     
     def __len__(self):
         if isinstance(self.targets, list):
             return len(self.targets)
         elif isinstance(self.targets, int):
             return 1
         else:
             return len(self.client)
     
     def set_flags(self, **kwargs):
         """set my attribute flags by keyword.
 
         Views determine behavior with a few attributes (`block`, `track`, etc.).
         These attributes can be set all at once by name with this method.
 
         Parameters
         ----------
 
         block : bool
             whether to wait for results
         track : bool
             whether to create a MessageTracker to allow the user to
             safely edit after arrays and buffers during non-copying
             sends.
         """
         for name, value in iteritems(kwargs):
             if name not in self._flag_names:
                 raise KeyError("Invalid name: %r"%name)
             else:
                 setattr(self, name, value)
 
     @contextmanager
     def temp_flags(self, **kwargs):
         """temporarily set flags, for use in `with` statements.
 
         See set_flags for permanent setting of flags
 
         Examples
         --------
 
         >>> view.track=False
         ...
         >>> with view.temp_flags(track=True):
         ...    ar = view.apply(dostuff, my_big_array)
         ...    ar.tracker.wait() # wait for send to finish
         >>> view.track
         False
 
         """
         # preflight: save flags, and set temporaries
         saved_flags = {}
         for f in self._flag_names:
             saved_flags[f] = getattr(self, f)
         self.set_flags(**kwargs)
         # yield to the with-statement block
         try:
             yield
         finally:
             # postflight: restore saved flags
             self.set_flags(**saved_flags)
 
 
     #----------------------------------------------------------------
     # apply
     #----------------------------------------------------------------
 
     def _sync_results(self):
         """to be called by @sync_results decorator
         
         after submitting any tasks.
         """
         delta = self.outstanding.difference(self.client.outstanding)
         completed = self.outstanding.intersection(delta)
         self.outstanding = self.outstanding.difference(completed)
         
     @sync_results
     @save_ids
     def _really_apply(self, f, args, kwargs, block=None, **options):
         """wrapper for client.send_apply_request"""
         raise NotImplementedError("Implement in subclasses")
 
     def apply(self, f, *args, **kwargs):
-        """calls f(*args, **kwargs) on remote engines, returning the result.
+        """calls ``f(*args, **kwargs)`` on remote engines, returning the result.
 
         This method sets all apply flags via this View's attributes.
 
-        if self.block is False:
-            returns AsyncResult
-        else:
-            returns actual result of f(*args, **kwargs)
+        Returns :class:`~IPython.parallel.client.asyncresult.AsyncResult`
+        instance if ``self.block`` is False, otherwise the return value of
+        ``f(*args, **kwargs)``.
         """
         return self._really_apply(f, args, kwargs)
 
     def apply_async(self, f, *args, **kwargs):
-        """calls f(*args, **kwargs) on remote engines in a nonblocking manner.
+        """calls ``f(*args, **kwargs)`` on remote engines in a nonblocking manner.
 
-        returns AsyncResult
+        Returns :class:`~IPython.parallel.client.asyncresult.AsyncResult` instance.
         """
         return self._really_apply(f, args, kwargs, block=False)
 
     @spin_after
     def apply_sync(self, f, *args, **kwargs):
-        """calls f(*args, **kwargs) on remote engines in a blocking manner,
+        """calls ``f(*args, **kwargs)`` on remote engines in a blocking manner,
          returning the result.
-
-        returns: actual result of f(*args, **kwargs)
         """
         return self._really_apply(f, args, kwargs, block=True)
 
     #----------------------------------------------------------------
     # wrappers for client and control methods
     #----------------------------------------------------------------
     @sync_results
     def spin(self):
         """spin the client, and sync"""
         self.client.spin()
 
     @sync_results
     def wait(self, jobs=None, timeout=-1):
         """waits on one or more `jobs`, for up to `timeout` seconds.
 
         Parameters
         ----------
 
         jobs : int, str, or list of ints and/or strs, or one or more AsyncResult objects
                 ints are indices to self.history
                 strs are msg_ids
                 default: wait on all outstanding messages
         timeout : float
                 a time in seconds, after which to give up.
                 default is -1, which means no timeout
 
         Returns
         -------
 
         True : when all msg_ids are done
         False : timeout reached, some msg_ids still outstanding
         """
         if jobs is None:
             jobs = self.history
         return self.client.wait(jobs, timeout)
 
     def abort(self, jobs=None, targets=None, block=None):
         """Abort jobs on my engines.
 
         Parameters
         ----------
 
         jobs : None, str, list of strs, optional
             if None: abort all jobs.
             else: abort specific msg_id(s).
         """
         block = block if block is not None else self.block
         targets = targets if targets is not None else self.targets
         jobs = jobs if jobs is not None else list(self.outstanding)
         
         return self.client.abort(jobs=jobs, targets=targets, block=block)
 
     def queue_status(self, targets=None, verbose=False):
         """Fetch the Queue status of my engines"""
         targets = targets if targets is not None else self.targets
         return self.client.queue_status(targets=targets, verbose=verbose)
 
     def purge_results(self, jobs=[], targets=[]):
         """Instruct the controller to forget specific results."""
         if targets is None or targets == 'all':
             targets = self.targets
         return self.client.purge_results(jobs=jobs, targets=targets)
 
     def shutdown(self, targets=None, restart=False, hub=False, block=None):
         """Terminates one or more engine processes, optionally including the hub.
         """
         block = self.block if block is None else block
         if targets is None or targets == 'all':
             targets = self.targets
         return self.client.shutdown(targets=targets, restart=restart, hub=hub, block=block)
 
     @spin_after
     def get_result(self, indices_or_msg_ids=None):
         """return one or more results, specified by history index or msg_id.
 
-        See client.get_result for details.
-
+        See :meth:`IPython.parallel.client.client.Client.get_result` for details.
         """
 
         if indices_or_msg_ids is None:
             indices_or_msg_ids = -1
         if isinstance(indices_or_msg_ids, int):
             indices_or_msg_ids = self.history[indices_or_msg_ids]
         elif isinstance(indices_or_msg_ids, (list,tuple,set)):
             indices_or_msg_ids = list(indices_or_msg_ids)
             for i,index in enumerate(indices_or_msg_ids):
                 if isinstance(index, int):
                     indices_or_msg_ids[i] = self.history[index]
         return self.client.get_result(indices_or_msg_ids)
 
     #-------------------------------------------------------------------
     # Map
     #-------------------------------------------------------------------
 
     @sync_results
     def map(self, f, *sequences, **kwargs):
         """override in subclasses"""
         raise NotImplementedError
 
     def map_async(self, f, *sequences, **kwargs):
-        """Parallel version of builtin `map`, using this view's engines.
+        """Parallel version of builtin :func:`python:map`, using this view's engines.
 
-        This is equivalent to map(...block=False)
+        This is equivalent to ``map(...block=False)``.
 
         See `self.map` for details.
         """
         if 'block' in kwargs:
             raise TypeError("map_async doesn't take a `block` keyword argument.")
         kwargs['block'] = False
         return self.map(f,*sequences,**kwargs)
 
     def map_sync(self, f, *sequences, **kwargs):
-        """Parallel version of builtin `map`, using this view's engines.
+        """Parallel version of builtin :func:`python:map`, using this view's engines.
 
-        This is equivalent to map(...block=True)
+        This is equivalent to ``map(...block=True)``.
 
         See `self.map` for details.
         """
         if 'block' in kwargs:
             raise TypeError("map_sync doesn't take a `block` keyword argument.")
         kwargs['block'] = True
         return self.map(f,*sequences,**kwargs)
 
     def imap(self, f, *sequences, **kwargs):
-        """Parallel version of `itertools.imap`.
+        """Parallel version of :func:`itertools.imap`.
 
         See `self.map` for details.
 
         """
 
         return iter(self.map_async(f,*sequences, **kwargs))
 
     #-------------------------------------------------------------------
     # Decorators
     #-------------------------------------------------------------------
 
     def remote(self, block=None, **flags):
         """Decorator for making a RemoteFunction"""
         block = self.block if block is None else block
         return remote(self, block=block, **flags)
 
     def parallel(self, dist='b', block=None, **flags):
         """Decorator for making a ParallelFunction"""
         block = self.block if block is None else block
         return parallel(self, dist=dist, block=block, **flags)
 
 @skip_doctest
 class DirectView(View):
     """Direct Multiplexer View of one or more engines.
 
     These are created via indexed access to a client:
 
     >>> dv_1 = client[1]
     >>> dv_all = client[:]
     >>> dv_even = client[::2]
     >>> dv_some = client[1:3]
 
     This object provides dictionary access to engine namespaces:
 
     # push a=5:
     >>> dv['a'] = 5
     # pull 'foo':
     >>> db['foo']
 
     """
 
     def __init__(self, client=None, socket=None, targets=None):
         super(DirectView, self).__init__(client=client, socket=socket, targets=targets)
 
     @property
     def importer(self):
         """sync_imports(local=True) as a property.
 
         See sync_imports for details.
 
         """
         return self.sync_imports(True)
 
     @contextmanager
     def sync_imports(self, local=True, quiet=False):
         """Context Manager for performing simultaneous local and remote imports.
 
         'import x as y' will *not* work.  The 'as y' part will simply be ignored.
         
         If `local=True`, then the package will also be imported locally.
         
         If `quiet=True`, no output will be produced when attempting remote 
         imports. 
         
         Note that remote-only (`local=False`) imports have not been implemented.
         
         >>> with view.sync_imports():
         ...    from numpy import recarray
         importing recarray from numpy on engine(s)
 
         """
         from IPython.utils.py3compat import builtin_mod
         local_import = builtin_mod.__import__
         modules = set()
         results = []
         @util.interactive
         def remote_import(name, fromlist, level):
             """the function to be passed to apply, that actually performs the import
             on the engine, and loads up the user namespace.
             """
             import sys
             user_ns = globals()
             mod = __import__(name, fromlist=fromlist, level=level)
             if fromlist:
                 for key in fromlist:
                     user_ns[key] = getattr(mod, key)
             else:
                 user_ns[name] = sys.modules[name]
 
         def view_import(name, globals={}, locals={}, fromlist=[], level=0):
             """the drop-in replacement for __import__, that optionally imports
             locally as well.
             """
             # don't override nested imports
             save_import = builtin_mod.__import__
             builtin_mod.__import__ = local_import
 
             if imp.lock_held():
                 # this is a side-effect import, don't do it remotely, or even
                 # ignore the local effects
                 return local_import(name, globals, locals, fromlist, level)
 
             imp.acquire_lock()
             if local:
                 mod = local_import(name, globals, locals, fromlist, level)
             else:
                 raise NotImplementedError("remote-only imports not yet implemented")
             imp.release_lock()
 
             key = name+':'+','.join(fromlist or [])
             if level <= 0 and key not in modules:
                 modules.add(key)
                 if not quiet:
                     if fromlist:
                         print("importing %s from %s on engine(s)"%(','.join(fromlist), name))
                     else:
                         print("importing %s on engine(s)"%name)
                 results.append(self.apply_async(remote_import, name, fromlist, level))
             # restore override
             builtin_mod.__import__ = save_import
 
             return mod
 
         # override __import__
         builtin_mod.__import__ = view_import
         try:
             # enter the block
             yield
         except ImportError:
             if local:
                 raise
             else:
                 # ignore import errors if not doing local imports
                 pass
         finally:
             # always restore __import__
             builtin_mod.__import__ = local_import
 
         for r in results:
             # raise possible remote ImportErrors here
             r.get()
 
 
     @sync_results
     @save_ids
     def _really_apply(self, f, args=None, kwargs=None, targets=None, block=None, track=None):
         """calls f(*args, **kwargs) on remote engines, returning the result.
 
         This method sets all of `apply`'s flags via this View's attributes.
 
         Parameters
         ----------
 
         f : callable
 
         args : list [default: empty]
 
         kwargs : dict [default: empty]
 
         targets : target list [default: self.targets]
             where to run
         block : bool [default: self.block]
             whether to block
         track : bool [default: self.track]
             whether to ask zmq to track the message, for safe non-copying sends
 
         Returns
         -------
 
         if self.block is False:
             returns AsyncResult
         else:
             returns actual result of f(*args, **kwargs) on the engine(s)
             This will be a list of self.targets is also a list (even length 1), or
             the single result if self.targets is an integer engine id
         """
         args = [] if args is None else args
         kwargs = {} if kwargs is None else kwargs
         block = self.block if block is None else block
         track = self.track if track is None else track
         targets = self.targets if targets is None else targets
         
         _idents, _targets = self.client._build_targets(targets)
         msg_ids = []
         trackers = []
         for ident in _idents:
             msg = self.client.send_apply_request(self._socket, f, args, kwargs, track=track,
                                     ident=ident)
             if track:
                 trackers.append(msg['tracker'])
             msg_ids.append(msg['header']['msg_id'])
         if isinstance(targets, int):
             msg_ids = msg_ids[0]
         tracker = None if track is False else zmq.MessageTracker(*trackers)
         ar = AsyncResult(self.client, msg_ids, fname=getname(f), targets=_targets, tracker=tracker)
         if block:
             try:
                 return ar.get()
             except KeyboardInterrupt:
                 pass
         return ar
 
 
     @sync_results
     def map(self, f, *sequences, **kwargs):
-        """view.map(f, *sequences, block=self.block) => list|AsyncMapResult
+        """``view.map(f, *sequences, block=self.block)`` => list|AsyncMapResult
 
         Parallel version of builtin `map`, using this View's `targets`.
 
         There will be one task per target, so work will be chunked
         if the sequences are longer than `targets`.
 
         Results can be iterated as they are ready, but will become available in chunks.
 
         Parameters
         ----------
 
         f : callable
             function to be mapped
         *sequences: one or more sequences of matching length
             the sequences to be distributed and passed to `f`
         block : bool
             whether to wait for the result or not [default self.block]
 
         Returns
         -------
 
-        if block=False:
-            AsyncMapResult
+
+        If block=False
+          An :class:`~IPython.parallel.client.asyncresult.AsyncMapResult` instance.
                 An object like AsyncResult, but which reassembles the sequence of results
                 into a single list. AsyncMapResults can be iterated through before all
                 results are complete.
-        else:
-            list
-                the result of map(f,*sequences)
+        else
+            A list, the result of ``map(f,*sequences)``
         """
 
         block = kwargs.pop('block', self.block)
         for k in kwargs.keys():
             if k not in ['block', 'track']:
                 raise TypeError("invalid keyword arg, %r"%k)
 
         assert len(sequences) > 0, "must have some sequences to map onto!"
         pf = ParallelFunction(self, f, block=block, **kwargs)
         return pf.map(*sequences)
 
     @sync_results
     @save_ids
     def execute(self, code, silent=True, targets=None, block=None):
         """Executes `code` on `targets` in blocking or nonblocking manner.
 
         ``execute`` is always `bound` (affects engine namespace)
 
         Parameters
         ----------
 
         code : str
                 the code string to be executed
         block : bool
                 whether or not to wait until done to return
                 default: self.block
         """
         block = self.block if block is None else block
         targets = self.targets if targets is None else targets
 
         _idents, _targets = self.client._build_targets(targets)
         msg_ids = []
         trackers = []
         for ident in _idents:
             msg = self.client.send_execute_request(self._socket, code, silent=silent, ident=ident)
             msg_ids.append(msg['header']['msg_id'])
         if isinstance(targets, int):
             msg_ids = msg_ids[0]
         ar = AsyncResult(self.client, msg_ids, fname='execute', targets=_targets)
         if block:
             try:
                 ar.get()
             except KeyboardInterrupt:
                 pass
         return ar
 
     def run(self, filename, targets=None, block=None):
         """Execute contents of `filename` on my engine(s).
 
         This simply reads the contents of the file and calls `execute`.
 
         Parameters
         ----------
 
         filename : str
                 The path to the file
         targets : int/str/list of ints/strs
                 the engines on which to execute
                 default : all
         block : bool
                 whether or not to wait until done
                 default: self.block
 
         """
         with open(filename, 'r') as f:
             # add newline in case of trailing indented whitespace
             # which will cause SyntaxError
             code = f.read()+'\n'
         return self.execute(code, block=block, targets=targets)
 
     def update(self, ns):
         """update remote namespace with dict `ns`
 
         See `push` for details.
         """
         return self.push(ns, block=self.block, track=self.track)
 
     def push(self, ns, targets=None, block=None, track=None):
         """update remote namespace with dict `ns`
 
         Parameters
         ----------
 
         ns : dict
             dict of keys with which to update engine namespace(s)
         block : bool [default : self.block]
             whether to wait to be notified of engine receipt
 
         """
 
         block = block if block is not None else self.block
         track = track if track is not None else self.track
         targets = targets if targets is not None else self.targets
         # applier = self.apply_sync if block else self.apply_async
         if not isinstance(ns, dict):
             raise TypeError("Must be a dict, not %s"%type(ns))
         return self._really_apply(util._push, kwargs=ns, block=block, track=track, targets=targets)
 
     def get(self, key_s):
         """get object(s) by `key_s` from remote namespace
 
         see `pull` for details.
         """
         # block = block if block is not None else self.block
         return self.pull(key_s, block=True)
 
     def pull(self, names, targets=None, block=None):
         """get object(s) by `name` from remote namespace
 
         will return one object if it is a key.
         can also take a list of keys, in which case it will return a list of objects.
         """
         block = block if block is not None else self.block
         targets = targets if targets is not None else self.targets
         applier = self.apply_sync if block else self.apply_async
         if isinstance(names, string_types):
             pass
         elif isinstance(names, (list,tuple,set)):
             for key in names:
                 if not isinstance(key, string_types):
                     raise TypeError("keys must be str, not type %r"%type(key))
         else:
             raise TypeError("names must be strs, not %r"%names)
         return self._really_apply(util._pull, (names,), block=block, targets=targets)
 
     def scatter(self, key, seq, dist='b', flatten=False, targets=None, block=None, track=None):
         """
         Partition a Python sequence and send the partitions to a set of engines.
         """
         block = block if block is not None else self.block
         track = track if track is not None else self.track
         targets = targets if targets is not None else self.targets
         
         # construct integer ID list:
         targets = self.client._build_targets(targets)[1]
 
         mapObject = Map.dists[dist]()
         nparts = len(targets)
         msg_ids = []
         trackers = []
         for index, engineid in enumerate(targets):
             partition = mapObject.getPartition(seq, index, nparts)
             if flatten and len(partition) == 1:
                 ns = {key: partition[0]}
             else:
                 ns = {key: partition}
             r = self.push(ns, block=False, track=track, targets=engineid)
             msg_ids.extend(r.msg_ids)
             if track:
                 trackers.append(r._tracker)
 
         if track:
             tracker = zmq.MessageTracker(*trackers)
         else:
             tracker = None
 
         r = AsyncResult(self.client, msg_ids, fname='scatter', targets=targets, tracker=tracker)
         if block:
             r.wait()
         else:
             return r
 
     @sync_results
     @save_ids
     def gather(self, key, dist='b', targets=None, block=None):
         """
         Gather a partitioned sequence on a set of engines as a single local seq.
         """
         block = block if block is not None else self.block
         targets = targets if targets is not None else self.targets
         mapObject = Map.dists[dist]()
         msg_ids = []
 
         # construct integer ID list:
         targets = self.client._build_targets(targets)[1]
         
         for index, engineid in enumerate(targets):
             msg_ids.extend(self.pull(key, block=False, targets=engineid).msg_ids)
 
         r = AsyncMapResult(self.client, msg_ids, mapObject, fname='gather')
 
         if block:
             try:
                 return r.get()
             except KeyboardInterrupt:
                 pass
         return r
 
     def __getitem__(self, key):
         return self.get(key)
 
     def __setitem__(self,key, value):
         self.update({key:value})
 
     def clear(self, targets=None, block=None):
         """Clear the remote namespaces on my engines."""
         block = block if block is not None else self.block
         targets = targets if targets is not None else self.targets
         return self.client.clear(targets=targets, block=block)
 
     #----------------------------------------
     # activate for %px, %autopx, etc. magics
     #----------------------------------------
 
     def activate(self, suffix=''):
         """Activate IPython magics associated with this View
         
         Defines the magics `%px, %autopx, %pxresult, %%px, %pxconfig`
         
         Parameters
         ----------
         
         suffix: str [default: '']
             The suffix, if any, for the magics.  This allows you to have
             multiple views associated with parallel magics at the same time.
             
             e.g. ``rc[::2].activate(suffix='_even')`` will give you
             the magics ``%px_even``, ``%pxresult_even``, etc. for running magics 
             on the even engines.
         """
         
         from IPython.parallel.client.magics import ParallelMagics
         
         try:
             # This is injected into __builtins__.
             ip = get_ipython()
         except NameError:
             print("The IPython parallel magics (%px, etc.) only work within IPython.")
             return
         
         M = ParallelMagics(ip, self, suffix)
         ip.magics_manager.register(M)
 
 
 @skip_doctest
 class LoadBalancedView(View):
     """An load-balancing View that only executes via the Task scheduler.
 
     Load-balanced views can be created with the client's `view` method:
 
     >>> v = client.load_balanced_view()
 
     or targets can be specified, to restrict the potential destinations:
 
     >>> v = client.client.load_balanced_view([1,3])
 
     which would restrict loadbalancing to between engines 1 and 3.
 
     """
 
     follow=Any()
     after=Any()
     timeout=CFloat()
     retries = Integer(0)
 
     _task_scheme = Any()
     _flag_names = List(['targets', 'block', 'track', 'follow', 'after', 'timeout', 'retries'])
 
     def __init__(self, client=None, socket=None, **flags):
         super(LoadBalancedView, self).__init__(client=client, socket=socket, **flags)
         self._task_scheme=client._task_scheme
 
     def _validate_dependency(self, dep):
         """validate a dependency.
 
         For use in `set_flags`.
         """
         if dep is None or isinstance(dep, string_types + (AsyncResult, Dependency)):
             return True
         elif isinstance(dep, (list,set, tuple)):
             for d in dep:
                 if not isinstance(d, string_types + (AsyncResult,)):
                     return False
         elif isinstance(dep, dict):
             if set(dep.keys()) != set(Dependency().as_dict().keys()):
                 return False
             if not isinstance(dep['msg_ids'], list):
                 return False
             for d in dep['msg_ids']:
                 if not isinstance(d, string_types):
                     return False
         else:
             return False
 
         return True
 
     def _render_dependency(self, dep):
         """helper for building jsonable dependencies from various input forms."""
         if isinstance(dep, Dependency):
             return dep.as_dict()
         elif isinstance(dep, AsyncResult):
             return dep.msg_ids
         elif dep is None:
             return []
         else:
             # pass to Dependency constructor
             return list(Dependency(dep))
 
     def set_flags(self, **kwargs):
         """set my attribute flags by keyword.
 
         A View is a wrapper for the Client's apply method, but with attributes
         that specify keyword arguments, those attributes can be set by keyword
         argument with this method.
 
         Parameters
         ----------
 
         block : bool
             whether to wait for results
         track : bool
             whether to create a MessageTracker to allow the user to
             safely edit after arrays and buffers during non-copying
             sends.
 
         after : Dependency or collection of msg_ids
             Only for load-balanced execution (targets=None)
             Specify a list of msg_ids as a time-based dependency.
             This job will only be run *after* the dependencies
             have been met.
 
         follow : Dependency or collection of msg_ids
             Only for load-balanced execution (targets=None)
             Specify a list of msg_ids as a location-based dependency.
             This job will only be run on an engine where this dependency
             is met.
 
         timeout : float/int or None
             Only for load-balanced execution (targets=None)
             Specify an amount of time (in seconds) for the scheduler to
             wait for dependencies to be met before failing with a
             DependencyTimeout.
 
         retries : int
             Number of times a task will be retried on failure.
         """
 
         super(LoadBalancedView, self).set_flags(**kwargs)
         for name in ('follow', 'after'):
             if name in kwargs:
                 value = kwargs[name]
                 if self._validate_dependency(value):
                     setattr(self, name, value)
                 else:
                     raise ValueError("Invalid dependency: %r"%value)
         if 'timeout' in kwargs:
             t = kwargs['timeout']
             if not isinstance(t, (int, float, type(None))):
                 if (not PY3) and (not isinstance(t, long)):
                     raise TypeError("Invalid type for timeout: %r"%type(t))
             if t is not None:
                 if t < 0:
                     raise ValueError("Invalid timeout: %s"%t)
             self.timeout = t
 
     @sync_results
     @save_ids
     def _really_apply(self, f, args=None, kwargs=None, block=None, track=None,
                                         after=None, follow=None, timeout=None,
                                         targets=None, retries=None):
         """calls f(*args, **kwargs) on a remote engine, returning the result.
 
         This method temporarily sets all of `apply`'s flags for a single call.
 
         Parameters
         ----------
 
         f : callable
 
         args : list [default: empty]
 
         kwargs : dict [default: empty]
 
         block : bool [default: self.block]
             whether to block
         track : bool [default: self.track]
             whether to ask zmq to track the message, for safe non-copying sends
 
         !!!!!! TODO: THE REST HERE  !!!!
 
         Returns
         -------
 
         if self.block is False:
             returns AsyncResult
         else:
             returns actual result of f(*args, **kwargs) on the engine(s)
             This will be a list of self.targets is also a list (even length 1), or
             the single result if self.targets is an integer engine id
         """
 
         # validate whether we can run
         if self._socket.closed:
             msg = "Task farming is disabled"
             if self._task_scheme == 'pure':
                 msg += " because the pure ZMQ scheduler cannot handle"
                 msg += " disappearing engines."
             raise RuntimeError(msg)
 
         if self._task_scheme == 'pure':
             # pure zmq scheme doesn't support extra features
             msg = "Pure ZMQ scheduler doesn't support the following flags:"
             "follow, after, retries, targets, timeout"
             if (follow or after or retries or targets or timeout):
                 # hard fail on Scheduler flags
                 raise RuntimeError(msg)
             if isinstance(f, dependent):
                 # soft warn on functional dependencies
                 warnings.warn(msg, RuntimeWarning)
 
         # build args
         args = [] if args is None else args
         kwargs = {} if kwargs is None else kwargs
         block = self.block if block is None else block
         track = self.track if track is None else track
         after = self.after if after is None else after
         retries = self.retries if retries is None else retries
         follow = self.follow if follow is None else follow
         timeout = self.timeout if timeout is None else timeout
         targets = self.targets if targets is None else targets
 
         if not isinstance(retries, int):
             raise TypeError('retries must be int, not %r'%type(retries))
 
         if targets is None:
             idents = []
         else:
             idents = self.client._build_targets(targets)[0]
             # ensure *not* bytes
             idents = [ ident.decode() for ident in idents ]
 
         after = self._render_dependency(after)
         follow = self._render_dependency(follow)
         metadata = dict(after=after, follow=follow, timeout=timeout, targets=idents, retries=retries)
 
         msg = self.client.send_apply_request(self._socket, f, args, kwargs, track=track,
                                 metadata=metadata)
         tracker = None if track is False else msg['tracker']
 
         ar = AsyncResult(self.client, msg['header']['msg_id'], fname=getname(f), targets=None, tracker=tracker)
 
         if block:
             try:
                 return ar.get()
             except KeyboardInterrupt:
                 pass
         return ar
 
     @sync_results
     @save_ids
     def map(self, f, *sequences, **kwargs):
-        """view.map(f, *sequences, block=self.block, chunksize=1, ordered=True) => list|AsyncMapResult
+        """``view.map(f, *sequences, block=self.block, chunksize=1, ordered=True)`` => list|AsyncMapResult
 
         Parallel version of builtin `map`, load-balanced by this View.
 
         `block`, and `chunksize` can be specified by keyword only.
 
         Each `chunksize` elements will be a separate task, and will be
         load-balanced. This lets individual elements be available for iteration
         as soon as they arrive.
 
         Parameters
         ----------
 
         f : callable
             function to be mapped
         *sequences: one or more sequences of matching length
             the sequences to be distributed and passed to `f`
         block : bool [default self.block]
             whether to wait for the result or not
         track : bool
             whether to create a MessageTracker to allow the user to
             safely edit after arrays and buffers during non-copying
             sends.
         chunksize : int [default 1]
             how many elements should be in each task.
         ordered : bool [default True]
             Whether the results should be gathered as they arrive, or enforce
             the order of submission.
             
             Only applies when iterating through AsyncMapResult as results arrive.
             Has no effect when block=True.
 
         Returns
         -------
 
-        if block=False:
-            AsyncMapResult
+        if block=False
+          An :class:`~IPython.parallel.client.asyncresult.AsyncMapResult` instance.
                 An object like AsyncResult, but which reassembles the sequence of results
                 into a single list. AsyncMapResults can be iterated through before all
                 results are complete.
-            else:
-                the result of map(f,*sequences)
-
+        else
+            A list, the result of ``map(f,*sequences)``
         """
 
         # default
         block = kwargs.get('block', self.block)
         chunksize = kwargs.get('chunksize', 1)
         ordered = kwargs.get('ordered', True)
 
         keyset = set(kwargs.keys())
         extra_keys = keyset.difference_update(set(['block', 'chunksize']))
         if extra_keys:
             raise TypeError("Invalid kwargs: %s"%list(extra_keys))
 
         assert len(sequences) > 0, "must have some sequences to map onto!"
 
         pf = ParallelFunction(self, f, block=block, chunksize=chunksize, ordered=ordered)
         return pf.map(*sequences)
 
 __all__ = ['LoadBalancedView', 'DirectView']

IPython/parallel/controller/dependency.py

@@ -1,230 +1,229 b''
 """Dependency utilities
 
 Authors:
 
 * Min RK
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  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.
 #-----------------------------------------------------------------------------
 
 from types import ModuleType
 
 from IPython.parallel.client.asyncresult import AsyncResult
 from IPython.parallel.error import UnmetDependency
 from IPython.parallel.util import interactive
 from IPython.utils import py3compat
 from IPython.utils.py3compat import string_types
 from IPython.utils.pickleutil import can, uncan
 
 class depend(object):
     """Dependency decorator, for use with tasks.
     
     `@depend` lets you define a function for engine dependencies
     just like you use `apply` for tasks.
     
     
     Examples
     --------
     ::
     
         @depend(df, a,b, c=5)
         def f(m,n,p)
         
         view.apply(f, 1,2,3)
     
     will call df(a,b,c=5) on the engine, and if it returns False or
     raises an UnmetDependency error, then the task will not be run
     and another engine will be tried.
     """
     def __init__(self, f, *args, **kwargs):
         self.f = f
         self.args = args
         self.kwargs = kwargs
     
     def __call__(self, f):
         return dependent(f, self.f, *self.args, **self.kwargs)
 
 class dependent(object):
     """A function that depends on another function.
     This is an object to prevent the closure used
     in traditional decorators, which are not picklable.
     """
 
     def __init__(self, f, df, *dargs, **dkwargs):
         self.f = f
         name = getattr(f, '__name__', 'f')
         if py3compat.PY3:
             self.__name__ = name
         else:
             self.func_name = name
         self.df = df
         self.dargs = dargs
         self.dkwargs = dkwargs
     
     def check_dependency(self):
         if self.df(*self.dargs, **self.dkwargs) is False:
             raise UnmetDependency()
     
     def __call__(self, *args, **kwargs):
         return self.f(*args, **kwargs)
     
     if not py3compat.PY3:
         @property
         def __name__(self):
             return self.func_name
 
 @interactive
 def _require(*modules, **mapping):
     """Helper for @require decorator."""
     from IPython.parallel.error import UnmetDependency
     from IPython.utils.pickleutil import uncan
     user_ns = globals()
     for name in modules:
         try:
             exec('import %s' % name, user_ns)
         except ImportError:
             raise UnmetDependency(name)
             
     for name, cobj in mapping.items():
         user_ns[name] = uncan(cobj, user_ns)
     return True
 
 def require(*objects, **mapping):
     """Simple decorator for requiring local objects and modules to be available
     when the decorated function is called on the engine.
     
     Modules specified by name or passed directly will be imported
     prior to calling the decorated function.
     
     Objects other than modules will be pushed as a part of the task.
     Functions can be passed positionally,
     and will be pushed to the engine with their __name__.
     Other objects can be passed by keyword arg.
     
-    Examples
-    --------
+    Examples::
     
     In [1]: @require('numpy')
        ...: def norm(a):
        ...:     return numpy.linalg.norm(a,2)
 
     In [2]: foo = lambda x: x*x
     In [3]: @require(foo)
        ...: def bar(a):
        ...:     return foo(1-a)
     """
     names = []
     for obj in objects:
         if isinstance(obj, ModuleType):
             obj = obj.__name__
         
         if isinstance(obj, string_types):
             names.append(obj)
         elif hasattr(obj, '__name__'):
             mapping[obj.__name__] = obj
         else:
             raise TypeError("Objects other than modules and functions "
                 "must be passed by kwarg, but got: %s" % type(obj)
             )
     
     for name, obj in mapping.items():
         mapping[name] = can(obj)
     return depend(_require, *names, **mapping)
 
 class Dependency(set):
     """An object for representing a set of msg_id dependencies.
     
     Subclassed from set().
     
     Parameters
     ----------
     dependencies: list/set of msg_ids or AsyncResult objects or output of Dependency.as_dict()
         The msg_ids to depend on
     all : bool [default True]
         Whether the dependency should be considered met when *all* depending tasks have completed
         or only when *any* have been completed.
     success : bool [default True]
         Whether to consider successes as fulfilling dependencies.
     failure : bool [default False]
         Whether to consider failures as fulfilling dependencies.
     
     If `all=success=True` and `failure=False`, then the task will fail with an ImpossibleDependency
         as soon as the first depended-upon task fails.
     """
     
     all=True
     success=True
     failure=True
     
     def __init__(self, dependencies=[], all=True, success=True, failure=False):
         if isinstance(dependencies, dict):
             # load from dict
             all = dependencies.get('all', True)
             success = dependencies.get('success', success)
             failure = dependencies.get('failure', failure)
             dependencies = dependencies.get('dependencies', [])
         ids = []
         
         # extract ids from various sources:
         if isinstance(dependencies, string_types + (AsyncResult,)):
             dependencies = [dependencies]
         for d in dependencies:
             if isinstance(d, string_types):
                 ids.append(d)
             elif isinstance(d, AsyncResult):
                 ids.extend(d.msg_ids)
             else:
                 raise TypeError("invalid dependency type: %r"%type(d))
         
         set.__init__(self, ids)
         self.all = all
         if not (success or failure):
             raise ValueError("Must depend on at least one of successes or failures!")
         self.success=success
         self.failure = failure
     
     def check(self, completed, failed=None):
         """check whether our dependencies have been met."""
         if len(self) == 0:
             return True
         against = set()
         if self.success:
             against = completed
         if failed is not None and self.failure:
             against = against.union(failed)
         if self.all:
             return self.issubset(against)
         else:
             return not self.isdisjoint(against)
     
     def unreachable(self, completed, failed=None):
         """return whether this dependency has become impossible."""
         if len(self) == 0:
             return False
         against = set()
         if not self.success:
             against = completed
         if failed is not None and not self.failure:
             against = against.union(failed)
         if self.all:
             return not self.isdisjoint(against)
         else:
             return self.issubset(against)
         
     
     def as_dict(self):
         """Represent this dependency as a dict. For json compatibility."""
         return dict(
             dependencies=list(self),
             all=self.all,
             success=self.success,
             failure=self.failure
         )
 
 
 __all__ = ['depend', 'require', 'dependent', 'Dependency']
 

IPython/parallel/controller/dictdb.py

@@ -1,312 +1,317 b''
 """A Task logger that presents our DB interface,
 but exists entirely in memory and implemented with dicts.
 
 Authors:
 
 * Min RK
 
 
-TaskRecords are dicts of the form:
+TaskRecords are dicts of the form::
+
 {
     'msg_id' : str(uuid),
     'client_uuid' : str(uuid),
     'engine_uuid' : str(uuid) or None,
     'header' : dict(header),
     'content': dict(content),
     'buffers': list(buffers),
     'submitted': datetime,
     'started': datetime or None,
     'completed': datetime or None,
     'resubmitted': datetime or None,
     'result_header' : dict(header) or None,
     'result_content' : dict(content) or None,
     'result_buffers' : list(buffers) or None,
 }
-With this info, many of the special categories of tasks can be defined by query:
 
-pending:  completed is None
-client's outstanding: client_uuid = uuid && completed is None
-MIA: arrived is None (and completed is None)
-etc.
+With this info, many of the special categories of tasks can be defined by query,
+e.g.:
+
+* pending: completed is None
+* client's outstanding: client_uuid = uuid && completed is None
+* MIA: arrived is None (and completed is None)
+
+EngineRecords are dicts of the form::
 
-EngineRecords are dicts of the form:
 {
     'eid' : int(id),
     'uuid': str(uuid)
 }
+
 This may be extended, but is currently.
 
-We support a subset of mongodb operators:
+We support a subset of mongodb operators::
+
     $lt,$gt,$lte,$gte,$ne,$in,$nin,$all,$mod,$exists
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-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.
 #-----------------------------------------------------------------------------
 
 from copy import deepcopy as copy
 from datetime import datetime
 
 from IPython.config.configurable import LoggingConfigurable
 
 from IPython.utils.py3compat import iteritems, itervalues
 from IPython.utils.traitlets import Dict, Unicode, Integer, Float
 
 filters = {
  '$lt' : lambda a,b: a < b,
  '$gt' : lambda a,b: b > a,
  '$eq' : lambda a,b: a == b,
  '$ne' : lambda a,b: a != b,
  '$lte': lambda a,b: a <= b,
  '$gte': lambda a,b: a >= b,
  '$in' : lambda a,b: a in b,
  '$nin': lambda a,b: a not in b,
  '$all': lambda a,b: all([ a in bb for bb in b ]),
  '$mod': lambda a,b: a%b[0] == b[1],
  '$exists' : lambda a,b: (b and a is not None) or (a is None and not b)
 }
 
 
 class CompositeFilter(object):
     """Composite filter for matching multiple properties."""
 
     def __init__(self, dikt):
         self.tests = []
         self.values = []
         for key, value in iteritems(dikt):
             self.tests.append(filters[key])
             self.values.append(value)
 
     def __call__(self, value):
         for test,check in zip(self.tests, self.values):
             if not test(value, check):
                 return False
         return True
 
 class BaseDB(LoggingConfigurable):
     """Empty Parent class so traitlets work on DB."""
     # base configurable traits:
     session = Unicode("")
 
 class DictDB(BaseDB):
     """Basic in-memory dict-based object for saving Task Records.
 
     This is the first object to present the DB interface
     for logging tasks out of memory.
 
     The interface is based on MongoDB, so adding a MongoDB
     backend should be straightforward.
     """
 
     _records = Dict()
     _culled_ids = set() # set of ids which have been culled
     _buffer_bytes = Integer(0) # running total of the bytes in the DB
     
     size_limit = Integer(1024**3, config=True,
         help="""The maximum total size (in bytes) of the buffers stored in the db
         
         When the db exceeds this size, the oldest records will be culled until
         the total size is under size_limit * (1-cull_fraction).
         default: 1 GB
         """
     )
     record_limit = Integer(1024, config=True,
         help="""The maximum number of records in the db
         
         When the history exceeds this size, the first record_limit * cull_fraction
         records will be culled.
         """
     )
     cull_fraction = Float(0.1, config=True,
         help="""The fraction by which the db should culled when one of the limits is exceeded
         
         In general, the db size will spend most of its time with a size in the range:
         
         [limit * (1-cull_fraction), limit]
         
         for each of size_limit and record_limit.
         """
     )
 
     def _match_one(self, rec, tests):
         """Check if a specific record matches tests."""
         for key,test in iteritems(tests):
             if not test(rec.get(key, None)):
                 return False
         return True
 
     def _match(self, check):
         """Find all the matches for a check dict."""
         matches = []
         tests = {}
         for k,v in iteritems(check):
             if isinstance(v, dict):
                 tests[k] = CompositeFilter(v)
             else:
                 tests[k] = lambda o: o==v
 
         for rec in itervalues(self._records):
             if self._match_one(rec, tests):
                 matches.append(copy(rec))
         return matches
 
     def _extract_subdict(self, rec, keys):
         """extract subdict of keys"""
         d = {}
         d['msg_id'] = rec['msg_id']
         for key in keys:
             d[key] = rec[key]
         return copy(d)
     
     # methods for monitoring size / culling history
     
     def _add_bytes(self, rec):
         for key in ('buffers', 'result_buffers'):
             for buf in rec.get(key) or []:
                 self._buffer_bytes += len(buf)
         
         self._maybe_cull()
     
     def _drop_bytes(self, rec):
         for key in ('buffers', 'result_buffers'):
             for buf in rec.get(key) or []:
                 self._buffer_bytes -= len(buf)
     
     def _cull_oldest(self, n=1):
         """cull the oldest N records"""
         for msg_id in self.get_history()[:n]:
             self.log.debug("Culling record: %r", msg_id)
             self._culled_ids.add(msg_id)
             self.drop_record(msg_id)
     
     def _maybe_cull(self):
         # cull by count:
         if len(self._records) > self.record_limit:
             to_cull = int(self.cull_fraction * self.record_limit)
             self.log.info("%i records exceeds limit of %i, culling oldest %i",
                 len(self._records), self.record_limit, to_cull
             )
             self._cull_oldest(to_cull)
         
         # cull by size:
         if self._buffer_bytes > self.size_limit:
             limit = self.size_limit * (1 - self.cull_fraction)
             
             before = self._buffer_bytes
             before_count = len(self._records)
             culled = 0
             while self._buffer_bytes > limit:
                 self._cull_oldest(1)
                 culled += 1
         
             self.log.info("%i records with total buffer size %i exceeds limit: %i. Culled oldest %i records.",
                 before_count, before, self.size_limit, culled
             )
     
     # public API methods:
 
     def add_record(self, msg_id, rec):
         """Add a new Task Record, by msg_id."""
         if msg_id in self._records:
             raise KeyError("Already have msg_id %r"%(msg_id))
         self._records[msg_id] = rec
         self._add_bytes(rec)
         self._maybe_cull()
 
     def get_record(self, msg_id):
         """Get a specific Task Record, by msg_id."""
         if msg_id in self._culled_ids:
             raise KeyError("Record %r has been culled for size" % msg_id)
         if not msg_id in self._records:
             raise KeyError("No such msg_id %r"%(msg_id))
         return copy(self._records[msg_id])
 
     def update_record(self, msg_id, rec):
         """Update the data in an existing record."""
         if msg_id in self._culled_ids:
             raise KeyError("Record %r has been culled for size" % msg_id)
         _rec = self._records[msg_id]
         self._drop_bytes(_rec)
         _rec.update(rec)
         self._add_bytes(_rec)
 
     def drop_matching_records(self, check):
         """Remove a record from the DB."""
         matches = self._match(check)
         for rec in matches:
             self._drop_bytes(rec)
             del self._records[rec['msg_id']]
 
     def drop_record(self, msg_id):
         """Remove a record from the DB."""
         rec = self._records[msg_id]
         self._drop_bytes(rec)
         del self._records[msg_id]
 
     def find_records(self, check, keys=None):
         """Find records matching a query dict, optionally extracting subset of keys.
 
         Returns dict keyed by msg_id of matching records.
 
         Parameters
         ----------
 
         check: dict
             mongodb-style query argument
         keys: list of strs [optional]
             if specified, the subset of keys to extract.  msg_id will *always* be
             included.
         """
         matches = self._match(check)
         if keys:
             return [ self._extract_subdict(rec, keys) for rec in matches ]
         else:
             return matches
 
     def get_history(self):
         """get all msg_ids, ordered by time submitted."""
         msg_ids = self._records.keys()
         # Remove any that do not have a submitted timestamp.
         # This is extremely unlikely to happen,
         # but it seems to come up in some tests on VMs.
         msg_ids = [ m for m in msg_ids if self._records[m]['submitted'] is not None ]
         return sorted(msg_ids, key=lambda m: self._records[m]['submitted'])
 
 
 NODATA = KeyError("NoDB backend doesn't store any data. "
 "Start the Controller with a DB backend to enable resubmission / result persistence."
 )
 
 
 class NoDB(BaseDB):
     """A blackhole db backend that actually stores no information.
     
     Provides the full DB interface, but raises KeyErrors on any
     method that tries to access the records.  This can be used to
     minimize the memory footprint of the Hub when its record-keeping
     functionality is not required.
     """
     
     def add_record(self, msg_id, record):
         pass
     
     def get_record(self, msg_id):
         raise NODATA
     
     def update_record(self, msg_id, record):
         pass
     
     def drop_matching_records(self, check):
         pass
     
     def drop_record(self, msg_id):
         pass
     
     def find_records(self, check, keys=None):
         raise NODATA
     
     def get_history(self):
         raise NODATA
 

IPython/parallel/controller/hub.py

@@ -1,1422 +1,1426 b''
 """The IPython Controller Hub with 0MQ
 This is the master object that handles connections from engines and clients,
 and monitors traffic through the various queues.
 
 Authors:
 
 * Min RK
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-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 __future__ import print_function
 
 import json
 import os
 import sys
 import time
 from datetime import datetime
 
 import zmq
 from zmq.eventloop import ioloop
 from zmq.eventloop.zmqstream import ZMQStream
 
 # internal:
 from IPython.utils.importstring import import_item
 from IPython.utils.jsonutil import extract_dates
 from IPython.utils.localinterfaces import localhost
 from IPython.utils.py3compat import cast_bytes, unicode_type, iteritems
 from IPython.utils.traitlets import (
         HasTraits, Instance, Integer, Unicode, Dict, Set, Tuple, CBytes, DottedObjectName
         )
 
 from IPython.parallel import error, util
 from IPython.parallel.factory import RegistrationFactory
 
 from IPython.kernel.zmq.session import SessionFactory
 
 from .heartmonitor import HeartMonitor
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def _passer(*args, **kwargs):
     return
 
 def _printer(*args, **kwargs):
     print (args)
     print (kwargs)
 
 def empty_record():
     """Return an empty dict with all record keys."""
     return {
         'msg_id' : None,
         'header' : None,
         'metadata' : None,
         'content': None,
         'buffers': None,
         'submitted': None,
         'client_uuid' : None,
         'engine_uuid' : None,
         'started': None,
         'completed': None,
         'resubmitted': None,
         'received': None,
         'result_header' : None,
         'result_metadata' : None,
         'result_content' : None,
         'result_buffers' : None,
         'queue' : None,
         'pyin' : None,
         'pyout': None,
         'pyerr': None,
         'stdout': '',
         'stderr': '',
     }
 
 def init_record(msg):
     """Initialize a TaskRecord based on a request."""
     header = msg['header']
     return {
         'msg_id' : header['msg_id'],
         'header' : header,
         'content': msg['content'],
         'metadata': msg['metadata'],
         'buffers': msg['buffers'],
         'submitted': header['date'],
         'client_uuid' : None,
         'engine_uuid' : None,
         'started': None,
         'completed': None,
         'resubmitted': None,
         'received': None,
         'result_header' : None,
         'result_metadata': None,
         'result_content' : None,
         'result_buffers' : None,
         'queue' : None,
         'pyin' : None,
         'pyout': None,
         'pyerr': None,
         'stdout': '',
         'stderr': '',
     }
 
 
 class EngineConnector(HasTraits):
     """A simple object for accessing the various zmq connections of an object.
     Attributes are:
     id (int): engine ID
     uuid (unicode): engine UUID
     pending: set of msg_ids
     stallback: DelayedCallback for stalled registration
     """
     
     id = Integer(0)
     uuid = Unicode()
     pending = Set()
     stallback = Instance(ioloop.DelayedCallback)
 
 
 _db_shortcuts = {
     'sqlitedb' : 'IPython.parallel.controller.sqlitedb.SQLiteDB',
     'mongodb'  : 'IPython.parallel.controller.mongodb.MongoDB',
     'dictdb'   : 'IPython.parallel.controller.dictdb.DictDB',
     'nodb'     : 'IPython.parallel.controller.dictdb.NoDB',
 }
 
 class HubFactory(RegistrationFactory):
     """The Configurable for setting up a Hub."""
 
     # port-pairs for monitoredqueues:
     hb = Tuple(Integer,Integer,config=True,
         help="""PUB/ROUTER Port pair for Engine heartbeats""")
     def _hb_default(self):
         return tuple(util.select_random_ports(2))
 
     mux = Tuple(Integer,Integer,config=True,
         help="""Client/Engine Port pair for MUX queue""")
 
     def _mux_default(self):
         return tuple(util.select_random_ports(2))
 
     task = Tuple(Integer,Integer,config=True,
         help="""Client/Engine Port pair for Task queue""")
     def _task_default(self):
         return tuple(util.select_random_ports(2))
 
     control = Tuple(Integer,Integer,config=True,
         help="""Client/Engine Port pair for Control queue""")
 
     def _control_default(self):
         return tuple(util.select_random_ports(2))
 
     iopub = Tuple(Integer,Integer,config=True,
         help="""Client/Engine Port pair for IOPub relay""")
 
     def _iopub_default(self):
         return tuple(util.select_random_ports(2))
 
     # single ports:
     mon_port = Integer(config=True,
         help="""Monitor (SUB) port for queue traffic""")
 
     def _mon_port_default(self):
         return util.select_random_ports(1)[0]
 
     notifier_port = Integer(config=True,
         help="""PUB port for sending engine status notifications""")
 
     def _notifier_port_default(self):
         return util.select_random_ports(1)[0]
 
     engine_ip = Unicode(config=True,
         help="IP on which to listen for engine connections. [default: loopback]")
     def _engine_ip_default(self):
         return localhost()
     engine_transport = Unicode('tcp', config=True,
         help="0MQ transport for engine connections. [default: tcp]")
 
     client_ip = Unicode(config=True,
         help="IP on which to listen for client connections. [default: loopback]")
     client_transport = Unicode('tcp', config=True,
         help="0MQ transport for client connections. [default : tcp]")
 
     monitor_ip = Unicode(config=True,
         help="IP on which to listen for monitor messages. [default: loopback]")
     monitor_transport = Unicode('tcp', config=True,
         help="0MQ transport for monitor messages. [default : tcp]")
 
     _client_ip_default = _monitor_ip_default = _engine_ip_default
 
 
     monitor_url = Unicode('')
 
     db_class = DottedObjectName('NoDB',
         config=True, help="""The class to use for the DB backend
         
         Options include:
         
         SQLiteDB: SQLite
         MongoDB : use MongoDB
         DictDB  : in-memory storage (fastest, but be mindful of memory growth of the Hub)
         NoDB    : disable database altogether (default)
         
         """)
 
     # not configurable
     db = Instance('IPython.parallel.controller.dictdb.BaseDB')
     heartmonitor = Instance('IPython.parallel.controller.heartmonitor.HeartMonitor')
 
     def _ip_changed(self, name, old, new):
         self.engine_ip = new
         self.client_ip = new
         self.monitor_ip = new
         self._update_monitor_url()
 
     def _update_monitor_url(self):
         self.monitor_url = "%s://%s:%i" % (self.monitor_transport, self.monitor_ip, self.mon_port)
 
     def _transport_changed(self, name, old, new):
         self.engine_transport = new
         self.client_transport = new
         self.monitor_transport = new
         self._update_monitor_url()
 
     def __init__(self, **kwargs):
         super(HubFactory, self).__init__(**kwargs)
         self._update_monitor_url()
 
 
     def construct(self):
         self.init_hub()
 
     def start(self):
         self.heartmonitor.start()
         self.log.info("Heartmonitor started")
 
     def client_url(self, channel):
         """return full zmq url for a named client channel"""
         return "%s://%s:%i" % (self.client_transport, self.client_ip, self.client_info[channel])
     
     def engine_url(self, channel):
         """return full zmq url for a named engine channel"""
         return "%s://%s:%i" % (self.engine_transport, self.engine_ip, self.engine_info[channel])
     
     def init_hub(self):
         """construct Hub object"""
 
         ctx = self.context
         loop = self.loop
         if 'TaskScheduler.scheme_name' in self.config:
             scheme = self.config.TaskScheduler.scheme_name
         else:
             from .scheduler import TaskScheduler
             scheme = TaskScheduler.scheme_name.get_default_value()
         
         # build connection dicts
         engine = self.engine_info = {
             'interface'     : "%s://%s" % (self.engine_transport, self.engine_ip),
             'registration'  : self.regport,
             'control'       : self.control[1],
             'mux'           : self.mux[1],
             'hb_ping'       : self.hb[0],
             'hb_pong'       : self.hb[1],
             'task'          : self.task[1],
             'iopub'         : self.iopub[1],
             }
 
         client = self.client_info = {
             'interface'     : "%s://%s" % (self.client_transport, self.client_ip),
             'registration'  : self.regport,
             'control'       : self.control[0],
             'mux'           : self.mux[0],
             'task'          : self.task[0],
             'task_scheme'   : scheme,
             'iopub'         : self.iopub[0],
             'notification'  : self.notifier_port,
             }
         
         self.log.debug("Hub engine addrs: %s", self.engine_info)
         self.log.debug("Hub client addrs: %s", self.client_info)
         
         # Registrar socket
         q = ZMQStream(ctx.socket(zmq.ROUTER), loop)
         util.set_hwm(q, 0)
         q.bind(self.client_url('registration'))
         self.log.info("Hub listening on %s for registration.", self.client_url('registration'))
         if self.client_ip != self.engine_ip:
             q.bind(self.engine_url('registration'))
             self.log.info("Hub listening on %s for registration.", self.engine_url('registration'))
 
         ### Engine connections ###
 
         # heartbeat
         hpub = ctx.socket(zmq.PUB)
         hpub.bind(self.engine_url('hb_ping'))
         hrep = ctx.socket(zmq.ROUTER)
         util.set_hwm(hrep, 0)
         hrep.bind(self.engine_url('hb_pong'))
         self.heartmonitor = HeartMonitor(loop=loop, parent=self, log=self.log,
                                 pingstream=ZMQStream(hpub,loop),
                                 pongstream=ZMQStream(hrep,loop)
                             )
 
         ### Client connections ###
         
         # Notifier socket
         n = ZMQStream(ctx.socket(zmq.PUB), loop)
         n.bind(self.client_url('notification'))
 
         ### build and launch the queues ###
 
         # monitor socket
         sub = ctx.socket(zmq.SUB)
         sub.setsockopt(zmq.SUBSCRIBE, b"")
         sub.bind(self.monitor_url)
         sub.bind('inproc://monitor')
         sub = ZMQStream(sub, loop)
 
         # connect the db
         db_class = _db_shortcuts.get(self.db_class.lower(), self.db_class)
         self.log.info('Hub using DB backend: %r', (db_class.split('.')[-1]))
         self.db = import_item(str(db_class))(session=self.session.session,
                                             parent=self, log=self.log)
         time.sleep(.25)
 
         # resubmit stream
         r = ZMQStream(ctx.socket(zmq.DEALER), loop)
         url = util.disambiguate_url(self.client_url('task'))
         r.connect(url)
 
         self.hub = Hub(loop=loop, session=self.session, monitor=sub, heartmonitor=self.heartmonitor,
                 query=q, notifier=n, resubmit=r, db=self.db,
                 engine_info=self.engine_info, client_info=self.client_info,
                 log=self.log)
 
 
 class Hub(SessionFactory):
     """The IPython Controller Hub with 0MQ connections
 
     Parameters
     ==========
     loop: zmq IOLoop instance
     session: Session object
     <removed> context: zmq context for creating new connections (?)
     queue: ZMQStream for monitoring the command queue (SUB)
     query: ZMQStream for engine registration and client queries requests (ROUTER)
     heartbeat: HeartMonitor object checking the pulse of the engines
     notifier: ZMQStream for broadcasting engine registration changes (PUB)
     db: connection to db for out of memory logging of commands
                 NotImplemented
     engine_info: dict of zmq connection information for engines to connect
                 to the queues.
     client_info: dict of zmq connection information for engines to connect
                 to the queues.
     """
     
     engine_state_file = Unicode()
     
     # internal data structures:
     ids=Set() # engine IDs
     keytable=Dict()
     by_ident=Dict()
     engines=Dict()
     clients=Dict()
     hearts=Dict()
     pending=Set()
     queues=Dict()  # pending msg_ids keyed by engine_id
     tasks=Dict() # pending msg_ids submitted as tasks, keyed by client_id
     completed=Dict() # completed msg_ids keyed by engine_id
     all_completed=Set() # completed msg_ids keyed by engine_id
     dead_engines=Set() # completed msg_ids keyed by engine_id
     unassigned=Set() # set of task msg_ds not yet assigned a destination
     incoming_registrations=Dict()
     registration_timeout=Integer()
     _idcounter=Integer(0)
 
     # objects from constructor:
     query=Instance(ZMQStream)
     monitor=Instance(ZMQStream)
     notifier=Instance(ZMQStream)
     resubmit=Instance(ZMQStream)
     heartmonitor=Instance(HeartMonitor)
     db=Instance(object)
     client_info=Dict()
     engine_info=Dict()
 
 
     def __init__(self, **kwargs):
         """
         # universal:
         loop: IOLoop for creating future connections
         session: streamsession for sending serialized data
         # engine:
         queue: ZMQStream for monitoring queue messages
         query: ZMQStream for engine+client registration and client requests
         heartbeat: HeartMonitor object for tracking engines
         # extra:
         db: ZMQStream for db connection (NotImplemented)
         engine_info: zmq address/protocol dict for engine connections
         client_info: zmq address/protocol dict for client connections
         """
 
         super(Hub, self).__init__(**kwargs)
         self.registration_timeout = max(10000, 5*self.heartmonitor.period)
 
         # register our callbacks
         self.query.on_recv(self.dispatch_query)
         self.monitor.on_recv(self.dispatch_monitor_traffic)
 
         self.heartmonitor.add_heart_failure_handler(self.handle_heart_failure)
         self.heartmonitor.add_new_heart_handler(self.handle_new_heart)
 
         self.monitor_handlers = {b'in' : self.save_queue_request,
                                 b'out': self.save_queue_result,
                                 b'intask': self.save_task_request,
                                 b'outtask': self.save_task_result,
                                 b'tracktask': self.save_task_destination,
                                 b'incontrol': _passer,
                                 b'outcontrol': _passer,
                                 b'iopub': self.save_iopub_message,
         }
 
         self.query_handlers = {'queue_request': self.queue_status,
                                 'result_request': self.get_results,
                                 'history_request': self.get_history,
                                 'db_request': self.db_query,
                                 'purge_request': self.purge_results,
                                 'load_request': self.check_load,
                                 'resubmit_request': self.resubmit_task,
                                 'shutdown_request': self.shutdown_request,
                                 'registration_request' : self.register_engine,
                                 'unregistration_request' : self.unregister_engine,
                                 'connection_request': self.connection_request,
         }
 
         # ignore resubmit replies
         self.resubmit.on_recv(lambda msg: None, copy=False)
 
         self.log.info("hub::created hub")
     
     @property
     def _next_id(self):
         """gemerate a new ID.
 
         No longer reuse old ids, just count from 0."""
         newid = self._idcounter
         self._idcounter += 1
         return newid
         # newid = 0
         # incoming = [id[0] for id in itervalues(self.incoming_registrations)]
         # # print newid, self.ids, self.incoming_registrations
         # while newid in self.ids or newid in incoming:
         #     newid += 1
         # return newid
     
     #-----------------------------------------------------------------------------
     # message validation
     #-----------------------------------------------------------------------------
 
     def _validate_targets(self, targets):
         """turn any valid targets argument into a list of integer ids"""
         if targets is None:
             # default to all
             return self.ids
 
         if isinstance(targets, (int,str,unicode_type)):
             # only one target specified
             targets = [targets]
         _targets = []
         for t in targets:
             # map raw identities to ids
             if isinstance(t, (str,unicode_type)):
                 t = self.by_ident.get(cast_bytes(t), t)
             _targets.append(t)
         targets = _targets
         bad_targets = [ t for t in targets if t not in self.ids ]
         if bad_targets:
             raise IndexError("No Such Engine: %r" % bad_targets)
         if not targets:
             raise IndexError("No Engines Registered")
         return targets
 
     #-----------------------------------------------------------------------------
     # dispatch methods (1 per stream)
     #-----------------------------------------------------------------------------
 
 
     @util.log_errors
     def dispatch_monitor_traffic(self, msg):
         """all ME and Task queue messages come through here, as well as
         IOPub traffic."""
         self.log.debug("monitor traffic: %r", msg[0])
         switch = msg[0]
         try:
             idents, msg = self.session.feed_identities(msg[1:])
         except ValueError:
             idents=[]
         if not idents:
             self.log.error("Monitor message without topic: %r", msg)
             return
         handler = self.monitor_handlers.get(switch, None)
         if handler is not None:
             handler(idents, msg)
         else:
             self.log.error("Unrecognized monitor topic: %r", switch)
 
 
     @util.log_errors
     def dispatch_query(self, msg):
         """Route registration requests and queries from clients."""
         try:
             idents, msg = self.session.feed_identities(msg)
         except ValueError:
             idents = []
         if not idents:
             self.log.error("Bad Query Message: %r", msg)
             return
         client_id = idents[0]
         try:
             msg = self.session.unserialize(msg, content=True)
         except Exception:
             content = error.wrap_exception()
             self.log.error("Bad Query Message: %r", msg, exc_info=True)
             self.session.send(self.query, "hub_error", ident=client_id,
                     content=content)
             return
         # print client_id, header, parent, content
         #switch on message type:
         msg_type = msg['header']['msg_type']
         self.log.info("client::client %r requested %r", client_id, msg_type)
         handler = self.query_handlers.get(msg_type, None)
         try:
             assert handler is not None, "Bad Message Type: %r" % msg_type
         except:
             content = error.wrap_exception()
             self.log.error("Bad Message Type: %r", msg_type, exc_info=True)
             self.session.send(self.query, "hub_error", ident=client_id,
                     content=content)
             return
 
         else:
             handler(idents, msg)
 
     def dispatch_db(self, msg):
         """"""
         raise NotImplementedError
 
     #---------------------------------------------------------------------------
     # handler methods (1 per event)
     #---------------------------------------------------------------------------
 
     #----------------------- Heartbeat --------------------------------------
 
     def handle_new_heart(self, heart):
         """handler to attach to heartbeater.
         Called when a new heart starts to beat.
         Triggers completion of registration."""
         self.log.debug("heartbeat::handle_new_heart(%r)", heart)
         if heart not in self.incoming_registrations:
             self.log.info("heartbeat::ignoring new heart: %r", heart)
         else:
             self.finish_registration(heart)
 
 
     def handle_heart_failure(self, heart):
         """handler to attach to heartbeater.
         called when a previously registered heart fails to respond to beat request.
         triggers unregistration"""
         self.log.debug("heartbeat::handle_heart_failure(%r)", heart)
         eid = self.hearts.get(heart, None)
         uuid = self.engines[eid].uuid
         if eid is None or self.keytable[eid] in self.dead_engines:
             self.log.info("heartbeat::ignoring heart failure %r (not an engine or already dead)", heart)
         else:
             self.unregister_engine(heart, dict(content=dict(id=eid, queue=uuid)))
 
     #----------------------- MUX Queue Traffic ------------------------------
 
     def save_queue_request(self, idents, msg):
         if len(idents) < 2:
             self.log.error("invalid identity prefix: %r", idents)
             return
         queue_id, client_id = idents[:2]
         try:
             msg = self.session.unserialize(msg)
         except Exception:
             self.log.error("queue::client %r sent invalid message to %r: %r", client_id, queue_id, msg, exc_info=True)
             return
 
         eid = self.by_ident.get(queue_id, None)
         if eid is None:
             self.log.error("queue::target %r not registered", queue_id)
             self.log.debug("queue::    valid are: %r", self.by_ident.keys())
             return
         record = init_record(msg)
         msg_id = record['msg_id']
         self.log.info("queue::client %r submitted request %r to %s", client_id, msg_id, eid)
         # Unicode in records
         record['engine_uuid'] = queue_id.decode('ascii')
         record['client_uuid'] = msg['header']['session']
         record['queue'] = 'mux'
 
         try:
             # it's posible iopub arrived first:
             existing = self.db.get_record(msg_id)
             for key,evalue in iteritems(existing):
                 rvalue = record.get(key, None)
                 if evalue and rvalue and evalue != rvalue:
                     self.log.warn("conflicting initial state for record: %r:%r <%r> %r", msg_id, rvalue, key, evalue)
                 elif evalue and not rvalue:
                     record[key] = evalue
             try:
                 self.db.update_record(msg_id, record)
             except Exception:
                 self.log.error("DB Error updating record %r", msg_id, exc_info=True)
         except KeyError:
             try:
                 self.db.add_record(msg_id, record)
             except Exception:
                 self.log.error("DB Error adding record %r", msg_id, exc_info=True)
 
 
         self.pending.add(msg_id)
         self.queues[eid].append(msg_id)
 
     def save_queue_result(self, idents, msg):
         if len(idents) < 2:
             self.log.error("invalid identity prefix: %r", idents)
             return
 
         client_id, queue_id = idents[:2]
         try:
             msg = self.session.unserialize(msg)
         except Exception:
             self.log.error("queue::engine %r sent invalid message to %r: %r",
                     queue_id, client_id, msg, exc_info=True)
             return
 
         eid = self.by_ident.get(queue_id, None)
         if eid is None:
             self.log.error("queue::unknown engine %r is sending a reply: ", queue_id)
             return
 
         parent = msg['parent_header']
         if not parent:
             return
         msg_id = parent['msg_id']
         if msg_id in self.pending:
             self.pending.remove(msg_id)
             self.all_completed.add(msg_id)
             self.queues[eid].remove(msg_id)
             self.completed[eid].append(msg_id)
             self.log.info("queue::request %r completed on %s", msg_id, eid)
         elif msg_id not in self.all_completed:
             # it could be a result from a dead engine that died before delivering the
             # result
             self.log.warn("queue:: unknown msg finished %r", msg_id)
             return
         # update record anyway, because the unregistration could have been premature
         rheader = msg['header']
         md = msg['metadata']
         completed = rheader['date']
         started = md.get('started', None)
         result = {
             'result_header' : rheader,
             'result_metadata': md,
             'result_content': msg['content'],
             'received': datetime.now(),
             'started' : started,
             'completed' : completed
         }
 
         result['result_buffers'] = msg['buffers']
         try:
             self.db.update_record(msg_id, result)
         except Exception:
             self.log.error("DB Error updating record %r", msg_id, exc_info=True)
 
 
     #--------------------- Task Queue Traffic ------------------------------
 
     def save_task_request(self, idents, msg):
         """Save the submission of a task."""
         client_id = idents[0]
 
         try:
             msg = self.session.unserialize(msg)
         except Exception:
             self.log.error("task::client %r sent invalid task message: %r",
                     client_id, msg, exc_info=True)
             return
         record = init_record(msg)
 
         record['client_uuid'] = msg['header']['session']
         record['queue'] = 'task'
         header = msg['header']
         msg_id = header['msg_id']
         self.pending.add(msg_id)
         self.unassigned.add(msg_id)
         try:
             # it's posible iopub arrived first:
             existing = self.db.get_record(msg_id)
             if existing['resubmitted']:
                 for key in ('submitted', 'client_uuid', 'buffers'):
                     # don't clobber these keys on resubmit
                     # submitted and client_uuid should be different
                     # and buffers might be big, and shouldn't have changed
                     record.pop(key)
                     # still check content,header which should not change
                     # but are not expensive to compare as buffers
 
             for key,evalue in iteritems(existing):
                 if key.endswith('buffers'):
                     # don't compare buffers
                     continue
                 rvalue = record.get(key, None)
                 if evalue and rvalue and evalue != rvalue:
                     self.log.warn("conflicting initial state for record: %r:%r <%r> %r", msg_id, rvalue, key, evalue)
                 elif evalue and not rvalue:
                     record[key] = evalue
             try:
                 self.db.update_record(msg_id, record)
             except Exception:
                 self.log.error("DB Error updating record %r", msg_id, exc_info=True)
         except KeyError:
             try:
                 self.db.add_record(msg_id, record)
             except Exception:
                 self.log.error("DB Error adding record %r", msg_id, exc_info=True)
         except Exception:
             self.log.error("DB Error saving task request %r", msg_id, exc_info=True)
 
     def save_task_result(self, idents, msg):
         """save the result of a completed task."""
         client_id = idents[0]
         try:
             msg = self.session.unserialize(msg)
         except Exception:
             self.log.error("task::invalid task result message send to %r: %r",
                     client_id, msg, exc_info=True)
             return
 
         parent = msg['parent_header']
         if not parent:
             # print msg
             self.log.warn("Task %r had no parent!", msg)
             return
         msg_id = parent['msg_id']
         if msg_id in self.unassigned:
             self.unassigned.remove(msg_id)
 
         header = msg['header']
         md = msg['metadata']
         engine_uuid = md.get('engine', u'')
         eid = self.by_ident.get(cast_bytes(engine_uuid), None)
         
         status = md.get('status', None)
 
         if msg_id in self.pending:
             self.log.info("task::task %r finished on %s", msg_id, eid)
             self.pending.remove(msg_id)
             self.all_completed.add(msg_id)
             if eid is not None:
                 if status != 'aborted':
                     self.completed[eid].append(msg_id)
                 if msg_id in self.tasks[eid]:
                     self.tasks[eid].remove(msg_id)
             completed = header['date']
             started = md.get('started', None)
             result = {
                 'result_header' : header,
                 'result_metadata': msg['metadata'],
                 'result_content': msg['content'],
                 'started' : started,
                 'completed' : completed,
                 'received' : datetime.now(),
                 'engine_uuid': engine_uuid,
             }
 
             result['result_buffers'] = msg['buffers']
             try:
                 self.db.update_record(msg_id, result)
             except Exception:
                 self.log.error("DB Error saving task request %r", msg_id, exc_info=True)
 
         else:
             self.log.debug("task::unknown task %r finished", msg_id)
 
     def save_task_destination(self, idents, msg):
         try:
             msg = self.session.unserialize(msg, content=True)
         except Exception:
             self.log.error("task::invalid task tracking message", exc_info=True)
             return
         content = msg['content']
         # print (content)
         msg_id = content['msg_id']
         engine_uuid = content['engine_id']
         eid = self.by_ident[cast_bytes(engine_uuid)]
 
         self.log.info("task::task %r arrived on %r", msg_id, eid)
         if msg_id in self.unassigned:
             self.unassigned.remove(msg_id)
         # else:
         #     self.log.debug("task::task %r not listed as MIA?!"%(msg_id))
 
         self.tasks[eid].append(msg_id)
         # self.pending[msg_id][1].update(received=datetime.now(),engine=(eid,engine_uuid))
         try:
             self.db.update_record(msg_id, dict(engine_uuid=engine_uuid))
         except Exception:
             self.log.error("DB Error saving task destination %r", msg_id, exc_info=True)
 
 
     def mia_task_request(self, idents, msg):
         raise NotImplementedError
         client_id = idents[0]
         # content = dict(mia=self.mia,status='ok')
         # self.session.send('mia_reply', content=content, idents=client_id)
 
 
     #--------------------- IOPub Traffic ------------------------------
 
     def save_iopub_message(self, topics, msg):
         """save an iopub message into the db"""
         # print (topics)
         try:
             msg = self.session.unserialize(msg, content=True)
         except Exception:
             self.log.error("iopub::invalid IOPub message", exc_info=True)
             return
 
         parent = msg['parent_header']
         if not parent:
             self.log.warn("iopub::IOPub message lacks parent: %r", msg)
             return
         msg_id = parent['msg_id']
         msg_type = msg['header']['msg_type']
         content = msg['content']
 
         # ensure msg_id is in db
         try:
             rec = self.db.get_record(msg_id)
         except KeyError:
             rec = empty_record()
             rec['msg_id'] = msg_id
             self.db.add_record(msg_id, rec)
         # stream
         d = {}
         if msg_type == 'stream':
             name = content['name']
             s = rec[name] or ''
             d[name] = s + content['data']
 
         elif msg_type == 'pyerr':
             d['pyerr'] = content
         elif msg_type == 'pyin':
             d['pyin'] = content['code']
         elif msg_type in ('display_data', 'pyout'):
             d[msg_type] = content
         elif msg_type == 'status':
             pass
         elif msg_type == 'data_pub':
             self.log.info("ignored data_pub message for %s" % msg_id)
         else:
             self.log.warn("unhandled iopub msg_type: %r", msg_type)
 
         if not d:
             return
 
         try:
             self.db.update_record(msg_id, d)
         except Exception:
             self.log.error("DB Error saving iopub message %r", msg_id, exc_info=True)
 
 
 
     #-------------------------------------------------------------------------
     # Registration requests
     #-------------------------------------------------------------------------
 
     def connection_request(self, client_id, msg):
         """Reply with connection addresses for clients."""
         self.log.info("client::client %r connected", client_id)
         content = dict(status='ok')
         jsonable = {}
         for k,v in iteritems(self.keytable):
             if v not in self.dead_engines:
                 jsonable[str(k)] = v
         content['engines'] = jsonable
         self.session.send(self.query, 'connection_reply', content, parent=msg, ident=client_id)
 
     def register_engine(self, reg, msg):
         """Register a new engine."""
         content = msg['content']
         try:
             uuid = content['uuid']
         except KeyError:
             self.log.error("registration::queue not specified", exc_info=True)
             return
 
         eid = self._next_id
 
         self.log.debug("registration::register_engine(%i, %r)", eid, uuid)
 
         content = dict(id=eid,status='ok',hb_period=self.heartmonitor.period)
         # check if requesting available IDs:
         if cast_bytes(uuid) in self.by_ident:
             try:
                 raise KeyError("uuid %r in use" % uuid)
             except:
                 content = error.wrap_exception()
                 self.log.error("uuid %r in use", uuid, exc_info=True)
         else:
             for h, ec in iteritems(self.incoming_registrations):
                 if uuid == h:
                     try:
                         raise KeyError("heart_id %r in use" % uuid)
                     except:
                         self.log.error("heart_id %r in use", uuid, exc_info=True)
                         content = error.wrap_exception()
                     break
                 elif uuid == ec.uuid:
                     try:
                         raise KeyError("uuid %r in use" % uuid)
                     except:
                         self.log.error("uuid %r in use", uuid, exc_info=True)
                         content = error.wrap_exception()
                     break
 
         msg = self.session.send(self.query, "registration_reply",
                 content=content,
                 ident=reg)
 
         heart = cast_bytes(uuid)
 
         if content['status'] == 'ok':
             if heart in self.heartmonitor.hearts:
                 # already beating
                 self.incoming_registrations[heart] = EngineConnector(id=eid,uuid=uuid)
                 self.finish_registration(heart)
             else:
                 purge = lambda : self._purge_stalled_registration(heart)
                 dc = ioloop.DelayedCallback(purge, self.registration_timeout, self.loop)
                 dc.start()
                 self.incoming_registrations[heart] = EngineConnector(id=eid,uuid=uuid,stallback=dc)
         else:
             self.log.error("registration::registration %i failed: %r", eid, content['evalue'])
         
         return eid
 
     def unregister_engine(self, ident, msg):
         """Unregister an engine that explicitly requested to leave."""
         try:
             eid = msg['content']['id']
         except:
             self.log.error("registration::bad engine id for unregistration: %r", ident, exc_info=True)
             return
         self.log.info("registration::unregister_engine(%r)", eid)
         # print (eid)
         uuid = self.keytable[eid]
         content=dict(id=eid, uuid=uuid)
         self.dead_engines.add(uuid)
         # self.ids.remove(eid)
         # uuid = self.keytable.pop(eid)
         #
         # ec = self.engines.pop(eid)
         # self.hearts.pop(ec.heartbeat)
         # self.by_ident.pop(ec.queue)
         # self.completed.pop(eid)
         handleit = lambda : self._handle_stranded_msgs(eid, uuid)
         dc = ioloop.DelayedCallback(handleit, self.registration_timeout, self.loop)
         dc.start()
         ############## TODO: HANDLE IT ################
         
         self._save_engine_state()
 
         if self.notifier:
             self.session.send(self.notifier, "unregistration_notification", content=content)
 
     def _handle_stranded_msgs(self, eid, uuid):
         """Handle messages known to be on an engine when the engine unregisters.
 
         It is possible that this will fire prematurely - that is, an engine will
         go down after completing a result, and the client will be notified
         that the result failed and later receive the actual result.
         """
 
         outstanding = self.queues[eid]
 
         for msg_id in outstanding:
             self.pending.remove(msg_id)
             self.all_completed.add(msg_id)
             try:
                 raise error.EngineError("Engine %r died while running task %r" % (eid, msg_id))
             except:
                 content = error.wrap_exception()
             # build a fake header:
             header = {}
             header['engine'] = uuid
             header['date'] = datetime.now()
             rec = dict(result_content=content, result_header=header, result_buffers=[])
             rec['completed'] = header['date']
             rec['engine_uuid'] = uuid
             try:
                 self.db.update_record(msg_id, rec)
             except Exception:
                 self.log.error("DB Error handling stranded msg %r", msg_id, exc_info=True)
 
 
     def finish_registration(self, heart):
         """Second half of engine registration, called after our HeartMonitor
         has received a beat from the Engine's Heart."""
         try:
             ec = self.incoming_registrations.pop(heart)
         except KeyError:
             self.log.error("registration::tried to finish nonexistant registration", exc_info=True)
             return
         self.log.info("registration::finished registering engine %i:%s", ec.id, ec.uuid)
         if ec.stallback is not None:
             ec.stallback.stop()
         eid = ec.id
         self.ids.add(eid)
         self.keytable[eid] = ec.uuid
         self.engines[eid] = ec
         self.by_ident[cast_bytes(ec.uuid)] = ec.id
         self.queues[eid] = list()
         self.tasks[eid] = list()
         self.completed[eid] = list()
         self.hearts[heart] = eid
         content = dict(id=eid, uuid=self.engines[eid].uuid)
         if self.notifier:
             self.session.send(self.notifier, "registration_notification", content=content)
         self.log.info("engine::Engine Connected: %i", eid)
         
         self._save_engine_state()
 
     def _purge_stalled_registration(self, heart):
         if heart in self.incoming_registrations:
             ec = self.incoming_registrations.pop(heart)
             self.log.info("registration::purging stalled registration: %i", ec.id)
         else:
             pass
 
     #-------------------------------------------------------------------------
     # Engine State
     #-------------------------------------------------------------------------
 
 
     def _cleanup_engine_state_file(self):
         """cleanup engine state mapping"""
         
         if os.path.exists(self.engine_state_file):
             self.log.debug("cleaning up engine state: %s", self.engine_state_file)
             try:
                 os.remove(self.engine_state_file)
             except IOError:
                 self.log.error("Couldn't cleanup file: %s", self.engine_state_file, exc_info=True)
 
 
     def _save_engine_state(self):
         """save engine mapping to JSON file"""
         if not self.engine_state_file:
             return
         self.log.debug("save engine state to %s" % self.engine_state_file)
         state = {}
         engines = {}
         for eid, ec in iteritems(self.engines):
             if ec.uuid not in self.dead_engines:
                 engines[eid] = ec.uuid
         
         state['engines'] = engines
         
         state['next_id'] = self._idcounter
         
         with open(self.engine_state_file, 'w') as f:
             json.dump(state, f)
 
 
     def _load_engine_state(self):
         """load engine mapping from JSON file"""
         if not os.path.exists(self.engine_state_file):
             return
         
         self.log.info("loading engine state from %s" % self.engine_state_file)
         
         with open(self.engine_state_file) as f:
             state = json.load(f)
         
         save_notifier = self.notifier
         self.notifier = None
         for eid, uuid in iteritems(state['engines']):
             heart = uuid.encode('ascii')
             # start with this heart as current and beating:
             self.heartmonitor.responses.add(heart)
             self.heartmonitor.hearts.add(heart)
             
             self.incoming_registrations[heart] = EngineConnector(id=int(eid), uuid=uuid)
             self.finish_registration(heart)
         
         self.notifier = save_notifier
         
         self._idcounter = state['next_id']
 
     #-------------------------------------------------------------------------
     # Client Requests
     #-------------------------------------------------------------------------
 
     def shutdown_request(self, client_id, msg):
         """handle shutdown request."""
         self.session.send(self.query, 'shutdown_reply', content={'status': 'ok'}, ident=client_id)
         # also notify other clients of shutdown
         self.session.send(self.notifier, 'shutdown_notice', content={'status': 'ok'})
         dc = ioloop.DelayedCallback(lambda : self._shutdown(), 1000, self.loop)
         dc.start()
 
     def _shutdown(self):
         self.log.info("hub::hub shutting down.")
         time.sleep(0.1)
         sys.exit(0)
 
 
     def check_load(self, client_id, msg):
         content = msg['content']
         try:
             targets = content['targets']
             targets = self._validate_targets(targets)
         except:
             content = error.wrap_exception()
             self.session.send(self.query, "hub_error",
                     content=content, ident=client_id)
             return
 
         content = dict(status='ok')
         # loads = {}
         for t in targets:
             content[bytes(t)] = len(self.queues[t])+len(self.tasks[t])
         self.session.send(self.query, "load_reply", content=content, ident=client_id)
 
 
     def queue_status(self, client_id, msg):
         """Return the Queue status of one or more targets.
-        if verbose: return the msg_ids
-        else: return len of each type.
-        keys: queue (pending MUX jobs)
-            tasks (pending Task jobs)
-            completed (finished jobs from both queues)"""
+
+        If verbose, return the msg_ids, else return len of each type.
+
+        Keys:
+
+        * queue (pending MUX jobs)
+        * tasks (pending Task jobs)
+        * completed (finished jobs from both queues)
+        """
         content = msg['content']
         targets = content['targets']
         try:
             targets = self._validate_targets(targets)
         except:
             content = error.wrap_exception()
             self.session.send(self.query, "hub_error",
                     content=content, ident=client_id)
             return
         verbose = content.get('verbose', False)
         content = dict(status='ok')
         for t in targets:
             queue = self.queues[t]
             completed = self.completed[t]
             tasks = self.tasks[t]
             if not verbose:
                 queue = len(queue)
                 completed = len(completed)
                 tasks = len(tasks)
             content[str(t)] = {'queue': queue, 'completed': completed , 'tasks': tasks}
         content['unassigned'] = list(self.unassigned) if verbose else len(self.unassigned)
         # print (content)
         self.session.send(self.query, "queue_reply", content=content, ident=client_id)
 
     def purge_results(self, client_id, msg):
         """Purge results from memory. This method is more valuable before we move
         to a DB based message storage mechanism."""
         content = msg['content']
         self.log.info("Dropping records with %s", content)
         msg_ids = content.get('msg_ids', [])
         reply = dict(status='ok')
         if msg_ids == 'all':
             try:
                 self.db.drop_matching_records(dict(completed={'$ne':None}))
             except Exception:
                 reply = error.wrap_exception()
         else:
             pending = [m for m in msg_ids if (m in self.pending)]
             if pending:
                 try:
                     raise IndexError("msg pending: %r" % pending[0])
                 except:
                     reply = error.wrap_exception()
             else:
                 try:
                     self.db.drop_matching_records(dict(msg_id={'$in':msg_ids}))
                 except Exception:
                     reply = error.wrap_exception()
 
             if reply['status'] == 'ok':
                 eids = content.get('engine_ids', [])
                 for eid in eids:
                     if eid not in self.engines:
                         try:
                             raise IndexError("No such engine: %i" % eid)
                         except:
                             reply = error.wrap_exception()
                         break
                     uid = self.engines[eid].uuid
                     try:
                         self.db.drop_matching_records(dict(engine_uuid=uid, completed={'$ne':None}))
                     except Exception:
                         reply = error.wrap_exception()
                         break
 
         self.session.send(self.query, 'purge_reply', content=reply, ident=client_id)
 
     def resubmit_task(self, client_id, msg):
         """Resubmit one or more tasks."""
         def finish(reply):
             self.session.send(self.query, 'resubmit_reply', content=reply, ident=client_id)
 
         content = msg['content']
         msg_ids = content['msg_ids']
         reply = dict(status='ok')
         try:
             records = self.db.find_records({'msg_id' : {'$in' : msg_ids}}, keys=[
                 'header', 'content', 'buffers'])
         except Exception:
             self.log.error('db::db error finding tasks to resubmit', exc_info=True)
             return finish(error.wrap_exception())
 
         # validate msg_ids
         found_ids = [ rec['msg_id'] for rec in records ]
         pending_ids = [ msg_id for msg_id in found_ids if msg_id in self.pending ]
         if len(records) > len(msg_ids):
             try:
                 raise RuntimeError("DB appears to be in an inconsistent state."
                     "More matching records were found than should exist")
             except Exception:
                 return finish(error.wrap_exception())
         elif len(records) < len(msg_ids):
             missing = [ m for m in msg_ids if m not in found_ids ]
             try:
                 raise KeyError("No such msg(s): %r" % missing)
             except KeyError:
                 return finish(error.wrap_exception())
         elif pending_ids:
             pass
             # no need to raise on resubmit of pending task, now that we
             # resubmit under new ID, but do we want to raise anyway?
             # msg_id = invalid_ids[0]
             # try:
             #     raise ValueError("Task(s) %r appears to be inflight" % )
             # except Exception:
             #     return finish(error.wrap_exception())
 
         # mapping of original IDs to resubmitted IDs
         resubmitted = {}
 
         # send the messages
         for rec in records:
             header = rec['header']
             msg = self.session.msg(header['msg_type'], parent=header)
             msg_id = msg['msg_id']
             msg['content'] = rec['content']
             
             # use the old header, but update msg_id and timestamp
             fresh = msg['header']
             header['msg_id'] = fresh['msg_id']
             header['date'] = fresh['date']
             msg['header'] = header
 
             self.session.send(self.resubmit, msg, buffers=rec['buffers'])
 
             resubmitted[rec['msg_id']] = msg_id
             self.pending.add(msg_id)
             msg['buffers'] = rec['buffers']
             try:
                 self.db.add_record(msg_id, init_record(msg))
             except Exception:
                 self.log.error("db::DB Error updating record: %s", msg_id, exc_info=True)
                 return finish(error.wrap_exception())
 
         finish(dict(status='ok', resubmitted=resubmitted))
         
         # store the new IDs in the Task DB
         for msg_id, resubmit_id in iteritems(resubmitted):
             try:
                 self.db.update_record(msg_id, {'resubmitted' : resubmit_id})
             except Exception:
                 self.log.error("db::DB Error updating record: %s", msg_id, exc_info=True)
 
 
     def _extract_record(self, rec):
         """decompose a TaskRecord dict into subsection of reply for get_result"""
         io_dict = {}
         for key in ('pyin', 'pyout', 'pyerr', 'stdout', 'stderr'):
                 io_dict[key] = rec[key]
         content = { 
             'header': rec['header'],
             'metadata': rec['metadata'],
             'result_metadata': rec['result_metadata'],
             'result_header' : rec['result_header'],
             'result_content': rec['result_content'],
             'received' : rec['received'],
             'io' : io_dict,
         }
         if rec['result_buffers']:
             buffers = list(map(bytes, rec['result_buffers']))
         else:
             buffers = []
 
         return content, buffers
 
     def get_results(self, client_id, msg):
         """Get the result of 1 or more messages."""
         content = msg['content']
         msg_ids = sorted(set(content['msg_ids']))
         statusonly = content.get('status_only', False)
         pending = []
         completed = []
         content = dict(status='ok')
         content['pending'] = pending
         content['completed'] = completed
         buffers = []
         if not statusonly:
             try:
                 matches = self.db.find_records(dict(msg_id={'$in':msg_ids}))
                 # turn match list into dict, for faster lookup
                 records = {}
                 for rec in matches:
                     records[rec['msg_id']] = rec
             except Exception:
                 content = error.wrap_exception()
                 self.session.send(self.query, "result_reply", content=content,
                                                     parent=msg, ident=client_id)
                 return
         else:
             records = {}
         for msg_id in msg_ids:
             if msg_id in self.pending:
                 pending.append(msg_id)
             elif msg_id in self.all_completed:
                 completed.append(msg_id)
                 if not statusonly:
                     c,bufs = self._extract_record(records[msg_id])
                     content[msg_id] = c
                     buffers.extend(bufs)
             elif msg_id in records:
                 if rec['completed']:
                     completed.append(msg_id)
                     c,bufs = self._extract_record(records[msg_id])
                     content[msg_id] = c
                     buffers.extend(bufs)
                 else:
                     pending.append(msg_id)
             else:
                 try:
                     raise KeyError('No such message: '+msg_id)
                 except:
                     content = error.wrap_exception()
                 break
         self.session.send(self.query, "result_reply", content=content,
                                             parent=msg, ident=client_id,
                                             buffers=buffers)
 
     def get_history(self, client_id, msg):
         """Get a list of all msg_ids in our DB records"""
         try:
             msg_ids = self.db.get_history()
         except Exception as e:
             content = error.wrap_exception()
         else:
             content = dict(status='ok', history=msg_ids)
 
         self.session.send(self.query, "history_reply", content=content,
                                             parent=msg, ident=client_id)
 
     def db_query(self, client_id, msg):
         """Perform a raw query on the task record database."""
         content = msg['content']
         query = extract_dates(content.get('query', {}))
         keys = content.get('keys', None)
         buffers = []
         empty = list()
         try:
             records = self.db.find_records(query, keys)
         except Exception as e:
             content = error.wrap_exception()
         else:
             # extract buffers from reply content:
             if keys is not None:
                 buffer_lens = [] if 'buffers' in keys else None
                 result_buffer_lens = [] if 'result_buffers' in keys else None
             else:
                 buffer_lens = None
                 result_buffer_lens = None
 
             for rec in records:
                 # buffers may be None, so double check
                 b = rec.pop('buffers', empty) or empty
                 if buffer_lens is not None:
                     buffer_lens.append(len(b))
                     buffers.extend(b)
                 rb = rec.pop('result_buffers', empty) or empty
                 if result_buffer_lens is not None:
                     result_buffer_lens.append(len(rb))
                     buffers.extend(rb)
             content = dict(status='ok', records=records, buffer_lens=buffer_lens,
                                     result_buffer_lens=result_buffer_lens)
         # self.log.debug (content)
         self.session.send(self.query, "db_reply", content=content,
                                             parent=msg, ident=client_id,
                                             buffers=buffers)
 

IPython/parallel/util.py

@@ -1,369 +1,370 b''
 """some generic utilities for dealing with classes, urls, and serialization
 
 Authors:
 
 * Min RK
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-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
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 import logging
 import os
 import re
 import stat
 import socket
 import sys
 from signal import signal, SIGINT, SIGABRT, SIGTERM
 try:
     from signal import SIGKILL
 except ImportError:
     SIGKILL=None
 
 try:
     import cPickle
     pickle = cPickle
 except:
     cPickle = None
     import pickle
 
 # System library imports
 import zmq
 from zmq.log import handlers
 
 from IPython.external.decorator import decorator
 
 # IPython imports
 from IPython.config.application import Application
 from IPython.utils.localinterfaces import localhost, is_public_ip, public_ips
 from IPython.utils.py3compat import string_types, iteritems, itervalues
 from IPython.kernel.zmq.log import EnginePUBHandler
 from IPython.kernel.zmq.serialize import (
     unserialize_object, serialize_object, pack_apply_message, unpack_apply_message
 )
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class Namespace(dict):
     """Subclass of dict for attribute access to keys."""
     
     def __getattr__(self, key):
         """getattr aliased to getitem"""
         if key in self:
             return self[key]
         else:
             raise NameError(key)
 
     def __setattr__(self, key, value):
         """setattr aliased to setitem, with strict"""
         if hasattr(dict, key):
             raise KeyError("Cannot override dict keys %r"%key)
         self[key] = value
     
 
 class ReverseDict(dict):
     """simple double-keyed subset of dict methods."""
     
     def __init__(self, *args, **kwargs):
         dict.__init__(self, *args, **kwargs)
         self._reverse = dict()
         for key, value in iteritems(self):
             self._reverse[value] = key
     
     def __getitem__(self, key):
         try:
             return dict.__getitem__(self, key)
         except KeyError:
             return self._reverse[key]
     
     def __setitem__(self, key, value):
         if key in self._reverse:
             raise KeyError("Can't have key %r on both sides!"%key)
         dict.__setitem__(self, key, value)
         self._reverse[value] = key
     
     def pop(self, key):
         value = dict.pop(self, key)
         self._reverse.pop(value)
         return value
     
     def get(self, key, default=None):
         try:
             return self[key]
         except KeyError:
             return default
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 @decorator
 def log_errors(f, self, *args, **kwargs):
     """decorator to log unhandled exceptions raised in a method.
     
     For use wrapping on_recv callbacks, so that exceptions
     do not cause the stream to be closed.
     """
     try:
         return f(self, *args, **kwargs)
     except Exception:
         self.log.error("Uncaught exception in %r" % f, exc_info=True)
     
 
 def is_url(url):
     """boolean check for whether a string is a zmq url"""
     if '://' not in url:
         return False
     proto, addr = url.split('://', 1)
     if proto.lower() not in ['tcp','pgm','epgm','ipc','inproc']:
         return False
     return True
 
 def validate_url(url):
     """validate a url for zeromq"""
     if not isinstance(url, string_types):
         raise TypeError("url must be a string, not %r"%type(url))
     url = url.lower()
     
     proto_addr = url.split('://')
     assert len(proto_addr) == 2, 'Invalid url: %r'%url
     proto, addr = proto_addr
     assert proto in ['tcp','pgm','epgm','ipc','inproc'], "Invalid protocol: %r"%proto
     
     # domain pattern adapted from http://www.regexlib.com/REDetails.aspx?regexp_id=391
     # author: Remi Sabourin
     pat = re.compile(r'^([\w\d]([\w\d\-]{0,61}[\w\d])?\.)*[\w\d]([\w\d\-]{0,61}[\w\d])?$')
     
     if proto == 'tcp':
         lis = addr.split(':')
         assert len(lis) == 2, 'Invalid url: %r'%url
         addr,s_port = lis
         try:
             port = int(s_port)
         except ValueError:
             raise AssertionError("Invalid port %r in url: %r"%(port, url))
         
         assert addr == '*' or pat.match(addr) is not None, 'Invalid url: %r'%url
         
     else:
         # only validate tcp urls currently
         pass
     
     return True
 
 
 def validate_url_container(container):
     """validate a potentially nested collection of urls."""
     if isinstance(container, string_types):
         url = container
         return validate_url(url)
     elif isinstance(container, dict):
         container = itervalues(container)
     
     for element in container:
         validate_url_container(element)
 
 
 def split_url(url):
     """split a zmq url (tcp://ip:port) into ('tcp','ip','port')."""
     proto_addr = url.split('://')
     assert len(proto_addr) == 2, 'Invalid url: %r'%url
     proto, addr = proto_addr
     lis = addr.split(':')
     assert len(lis) == 2, 'Invalid url: %r'%url
     addr,s_port = lis
     return proto,addr,s_port
     
 def disambiguate_ip_address(ip, location=None):
     """turn multi-ip interfaces '0.0.0.0' and '*' into connectable
     ones, based on the location (default interpretation of location is localhost)."""
     if ip in ('0.0.0.0', '*'):
         if location is None or is_public_ip(location) or not public_ips():
             # If location is unspecified or cannot be determined, assume local
             ip = localhost()
         elif location:
             return location
     return ip
 
 def disambiguate_url(url, location=None):
     """turn multi-ip interfaces '0.0.0.0' and '*' into connectable
     ones, based on the location (default interpretation is localhost).
     
-    This is for zeromq urls, such as tcp://*:10101."""
+    This is for zeromq urls, such as ``tcp://*:10101``.
+    """
     try:
         proto,ip,port = split_url(url)
     except AssertionError:
         # probably not tcp url; could be ipc, etc.
         return url
     
     ip = disambiguate_ip_address(ip,location)
     
     return "%s://%s:%s"%(proto,ip,port)
 
 
 #--------------------------------------------------------------------------
 # helpers for implementing old MEC API via view.apply
 #--------------------------------------------------------------------------
 
 def interactive(f):
     """decorator for making functions appear as interactively defined.
     This results in the function being linked to the user_ns as globals()
     instead of the module globals().
     """
     f.__module__ = '__main__'
     return f
 
 @interactive
 def _push(**ns):
     """helper method for implementing `client.push` via `client.apply`"""
     user_ns = globals()
     tmp = '_IP_PUSH_TMP_'
     while tmp in user_ns:
         tmp = tmp + '_'
     try:
         for name, value in ns.items():
             user_ns[tmp] = value
             exec("%s = %s" % (name, tmp), user_ns)
     finally:
         user_ns.pop(tmp, None)
 
 @interactive
 def _pull(keys):
     """helper method for implementing `client.pull` via `client.apply`"""
     if isinstance(keys, (list,tuple, set)):
         return [eval(key, globals()) for key in keys]
     else:
         return eval(keys, globals())
 
 @interactive
 def _execute(code):
     """helper method for implementing `client.execute` via `client.apply`"""
     exec(code, globals())
 
 #--------------------------------------------------------------------------
 # extra process management utilities
 #--------------------------------------------------------------------------
 
 _random_ports = set()
 
 def select_random_ports(n):
     """Selects and return n random ports that are available."""
     ports = []
     for i in range(n):
         sock = socket.socket()
         sock.bind(('', 0))
         while sock.getsockname()[1] in _random_ports:
             sock.close()
             sock = socket.socket()
             sock.bind(('', 0))
         ports.append(sock)
     for i, sock in enumerate(ports):
         port = sock.getsockname()[1]
         sock.close()
         ports[i] = port
         _random_ports.add(port)
     return ports
 
 def signal_children(children):
     """Relay interupt/term signals to children, for more solid process cleanup."""
     def terminate_children(sig, frame):
         log = Application.instance().log
         log.critical("Got signal %i, terminating children..."%sig)
         for child in children:
             child.terminate()
         
         sys.exit(sig != SIGINT)
         # sys.exit(sig)
     for sig in (SIGINT, SIGABRT, SIGTERM):
         signal(sig, terminate_children)
 
 def generate_exec_key(keyfile):
     import uuid
     newkey = str(uuid.uuid4())
     with open(keyfile, 'w') as f:
         # f.write('ipython-key ')
         f.write(newkey+'\n')
     # set user-only RW permissions (0600)
     # this will have no effect on Windows
     os.chmod(keyfile, stat.S_IRUSR|stat.S_IWUSR)
 
 
 def integer_loglevel(loglevel):
     try:
         loglevel = int(loglevel)
     except ValueError:
         if isinstance(loglevel, str):
             loglevel = getattr(logging, loglevel)
     return loglevel
 
 def connect_logger(logname, context, iface, root="ip", loglevel=logging.DEBUG):
     logger = logging.getLogger(logname)
     if any([isinstance(h, handlers.PUBHandler) for h in logger.handlers]):
         # don't add a second PUBHandler
         return
     loglevel = integer_loglevel(loglevel)
     lsock = context.socket(zmq.PUB)
     lsock.connect(iface)
     handler = handlers.PUBHandler(lsock)
     handler.setLevel(loglevel)
     handler.root_topic = root
     logger.addHandler(handler)
     logger.setLevel(loglevel)
 
 def connect_engine_logger(context, iface, engine, loglevel=logging.DEBUG):
     logger = logging.getLogger()
     if any([isinstance(h, handlers.PUBHandler) for h in logger.handlers]):
         # don't add a second PUBHandler
         return
     loglevel = integer_loglevel(loglevel)
     lsock = context.socket(zmq.PUB)
     lsock.connect(iface)
     handler = EnginePUBHandler(engine, lsock)
     handler.setLevel(loglevel)
     logger.addHandler(handler)
     logger.setLevel(loglevel)
     return logger
 
 def local_logger(logname, loglevel=logging.DEBUG):
     loglevel = integer_loglevel(loglevel)
     logger = logging.getLogger(logname)
     if any([isinstance(h, logging.StreamHandler) for h in logger.handlers]):
         # don't add a second StreamHandler
         return
     handler = logging.StreamHandler()
     handler.setLevel(loglevel)
     formatter = logging.Formatter("%(asctime)s.%(msecs).03d [%(name)s] %(message)s",
                 datefmt="%Y-%m-%d %H:%M:%S")
     handler.setFormatter(formatter)
 
     logger.addHandler(handler)
     logger.setLevel(loglevel)
     return logger
 
 def set_hwm(sock, hwm=0):
     """set zmq High Water Mark on a socket
     
     in a way that always works for various pyzmq / libzmq versions.
     """
     import zmq
     
     for key in ('HWM', 'SNDHWM', 'RCVHWM'):
         opt = getattr(zmq, key, None)
         if opt is None:
             continue
         try:
             sock.setsockopt(opt, hwm)
         except zmq.ZMQError:
             pass
 
         
  No newline at end of file

IPython/terminal/interactiveshell.py

@@ -1,692 +1,691 b''
 # -*- coding: utf-8 -*-
 """Subclass of InteractiveShell for terminal based frontends."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2001 Janko Hauser <[e-mail]>
 #  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #  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 __future__ import print_function
 
 import bdb
 import os
 import sys
 
 from IPython.core.error import TryNext, UsageError
 from IPython.core.usage import interactive_usage, default_banner
 from IPython.core.inputsplitter import IPythonInputSplitter
 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.lib.clipboard import ClipboardEmpty
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.encoding import get_stream_enc
 from IPython.utils import py3compat
 from IPython.utils.terminal import toggle_set_term_title, set_term_title
 from IPython.utils.process import abbrev_cwd
 from IPython.utils.warn import warn, error
 from IPython.utils.text import num_ini_spaces, SList, strip_email_quotes
 from IPython.utils.traitlets import Integer, CBool, Unicode
 
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
 def get_default_editor():
     try:
         ed = os.environ['EDITOR']
     except KeyError:
         if os.name == 'posix':
             ed = 'vi'  # the only one guaranteed to be there!
         else:
             ed = 'notepad' # same in Windows!
     return ed
 
 
 def get_pasted_lines(sentinel, l_input=py3compat.input):
     """ Yield pasted lines until the user enters the given sentinel value.
     """
     print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
           % sentinel)
     while True:
         try:
             l = l_input(':')
             if l == sentinel:
                 return
             else:
                 yield l
         except EOFError:
             print('<EOF>')
             return
 
 
 #------------------------------------------------------------------------
 # Terminal-specific magics
 #------------------------------------------------------------------------
 
 @magics_class
 class TerminalMagics(Magics):
     def __init__(self, shell):
         super(TerminalMagics, self).__init__(shell)
         self.input_splitter = IPythonInputSplitter()
         
     def store_or_execute(self, block, name):
         """ Execute a block, or store it in a variable, per the user's request.
         """
         if name:
             # If storing it for further editing
             self.shell.user_ns[name] = SList(block.splitlines())
             print("Block assigned to '%s'" % name)
         else:
             b = self.preclean_input(block)
             self.shell.user_ns['pasted_block'] = b
             self.shell.using_paste_magics = True
             try:
                 self.shell.run_cell(b)
             finally:
                 self.shell.using_paste_magics = False
     
     def preclean_input(self, block):
         lines = block.splitlines()
         while lines and not lines[0].strip():
             lines = lines[1:]
         return strip_email_quotes('\n'.join(lines))
 
     def rerun_pasted(self, name='pasted_block'):
         """ Rerun a previously pasted command.
         """
         b = self.shell.user_ns.get(name)
 
         # Sanity checks
         if b is None:
             raise UsageError('No previous pasted block available')
         if not isinstance(b, py3compat.string_types):
             raise UsageError(
                 "Variable 'pasted_block' is not a string, can't execute")
 
         print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
         self.shell.run_cell(b)
 
     @line_magic
     def autoindent(self, parameter_s = ''):
         """Toggle autoindent on/off (if available)."""
 
         self.shell.set_autoindent()
         print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
 
     @skip_doctest
     @line_magic
     def cpaste(self, parameter_s=''):
         """Paste & execute a pre-formatted code block from clipboard.
 
         You must terminate the block with '--' (two minus-signs) or Ctrl-D
         alone on the line. You can also provide your own sentinel with '%paste
         -s %%' ('%%' is the new sentinel for this operation)
 
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
         ignored, to allow pasting directly from e-mails, diff files and
         doctests (the '...' continuation prompt is also stripped).  The
         executed block is also assigned to variable named 'pasted_block' for
         later editing with '%edit pasted_block'.
 
         You can also pass a variable name as an argument, e.g. '%cpaste foo'.
         This assigns the pasted block to variable 'foo' as string, without
         dedenting or executing it (preceding >>> and + is still stripped)
 
         '%cpaste -r' re-executes the block previously entered by cpaste.
 
         Do not be alarmed by garbled output on Windows (it's a readline bug).
         Just press enter and type -- (and press enter again) and the block
         will be what was just pasted.
 
         IPython statements (magics, shell escapes) are not supported (yet).
 
         See also
         --------
         paste: automatically pull code from clipboard.
 
         Examples
         --------
         ::
 
           In [8]: %cpaste
           Pasting code; enter '--' alone on the line to stop.
           :>>> a = ["world!", "Hello"]
           :>>> print " ".join(sorted(a))
           :--
           Hello world!
         """
         opts, name = self.parse_options(parameter_s, 'rs:', mode='string')
         if 'r' in opts:
             self.rerun_pasted()
             return
 
         sentinel = opts.get('s', '--')
         block = '\n'.join(get_pasted_lines(sentinel))
         self.store_or_execute(block, name)
 
     @line_magic
     def paste(self, parameter_s=''):
         """Paste & execute a pre-formatted code block from clipboard.
 
         The text is pulled directly from the clipboard without user
         intervention and printed back on the screen before execution (unless
         the -q flag is given to force quiet mode).
 
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
         ignored, to allow pasting directly from e-mails, diff files and
         doctests (the '...' continuation prompt is also stripped).  The
         executed block is also assigned to variable named 'pasted_block' for
         later editing with '%edit pasted_block'.
 
         You can also pass a variable name as an argument, e.g. '%paste foo'.
         This assigns the pasted block to variable 'foo' as string, without
         executing it (preceding >>> and + is still stripped).
 
         Options:
 
           -r: re-executes the block previously entered by cpaste.
 
           -q: quiet mode: do not echo the pasted text back to the terminal.
 
         IPython statements (magics, shell escapes) are not supported (yet).
 
         See also
         --------
         cpaste: manually paste code into terminal until you mark its end.
         """
         opts, name = self.parse_options(parameter_s, 'rq', mode='string')
         if 'r' in opts:
             self.rerun_pasted()
             return
         try:
             block = self.shell.hooks.clipboard_get()
         except TryNext as clipboard_exc:
             message = getattr(clipboard_exc, 'args')
             if message:
                 error(message[0])
             else:
                 error('Could not get text from the clipboard.')
             return
         except ClipboardEmpty:
             raise UsageError("The clipboard appears to be empty")
 
         # By default, echo back to terminal unless quiet mode is requested
         if 'q' not in opts:
             write = self.shell.write
             write(self.shell.pycolorize(block))
             if not block.endswith('\n'):
                 write('\n')
             write("## -- End pasted text --\n")
 
         self.store_or_execute(block, name)
 
     # Class-level: add a '%cls' magic only on Windows
     if sys.platform == 'win32':
         @line_magic
         def cls(self, s):
             """Clear screen.
             """
             os.system("cls")
 
 #-----------------------------------------------------------------------------
 # Main class
 #-----------------------------------------------------------------------------
 
 class TerminalInteractiveShell(InteractiveShell):
 
     autoedit_syntax = CBool(False, config=True,
         help="auto editing of files with syntax errors.")
     banner = Unicode('')
     banner1 = Unicode(default_banner, config=True,
         help="""The part of the banner to be printed before the profile"""
     )
     banner2 = Unicode('', config=True,
         help="""The part of the banner to be printed after the profile"""
     )
     confirm_exit = CBool(True, config=True,
         help="""
         Set to confirm when you try to exit IPython with an EOF (Control-D
         in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
         you can force a direct exit without any confirmation.""",
     )
     # This display_banner only controls whether or not self.show_banner()
     # is called when mainloop/interact are called.  The default is False
     # because for the terminal based application, the banner behavior
     # is controlled by Global.display_banner, which IPythonApp looks at
     # to determine if *it* should call show_banner() by hand or not.
     display_banner = CBool(False) # This isn't configurable!
     embedded = CBool(False)
     embedded_active = CBool(False)
     editor = Unicode(get_default_editor(), config=True,
         help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
     )
     pager = Unicode('less', config=True,
         help="The shell program to be used for paging.")
 
     screen_length = Integer(0, config=True,
         help=
         """Number of lines of your screen, used to control printing of very
         long strings.  Strings longer than this number of lines will be sent
         through a pager instead of directly printed.  The default value for
         this is 0, which means IPython will auto-detect your screen size every
         time it needs to print certain potentially long strings (this doesn't
         change the behavior of the 'print' keyword, it's only triggered
         internally). If for some reason this isn't working well (it needs
         curses support), specify it yourself. Otherwise don't change the
         default.""",
     )
     term_title = CBool(False, config=True,
         help="Enable auto setting the terminal title."
     )
     
     # This `using_paste_magics` is used to detect whether the code is being
     # executed via paste magics functions
     using_paste_magics = CBool(False)
 
     # In the terminal, GUI control is done via PyOS_InputHook
     @staticmethod
     def enable_gui(gui=None, app=None):
         """Switch amongst GUI input hooks by name.
         """
         # Deferred import
         from IPython.lib.inputhook import enable_gui as real_enable_gui
         try:
             return real_enable_gui(gui, app)
         except ValueError as e:
             raise UsageError("%s" % e)
     
     def __init__(self, config=None, ipython_dir=None, profile_dir=None,
                  user_ns=None, user_module=None, custom_exceptions=((),None),
                  usage=None, banner1=None, banner2=None, display_banner=None,
                  **kwargs):
 
         super(TerminalInteractiveShell, self).__init__(
             config=config, ipython_dir=ipython_dir, profile_dir=profile_dir, user_ns=user_ns,
             user_module=user_module, custom_exceptions=custom_exceptions,
             **kwargs
         )
         # use os.system instead of utils.process.system by default,
         # because piped system doesn't make sense in the Terminal:
         self.system = self.system_raw
 
         self.init_term_title()
         self.init_usage(usage)
         self.init_banner(banner1, banner2, display_banner)
 
     #-------------------------------------------------------------------------
     # Overrides of init stages
     #-------------------------------------------------------------------------
 
     def init_display_formatter(self):
         super(TerminalInteractiveShell, self).init_display_formatter()
         # terminal only supports plaintext
         self.display_formatter.active_types = ['text/plain']
 
     #-------------------------------------------------------------------------
     # Things related to the terminal
     #-------------------------------------------------------------------------
 
     @property
     def usable_screen_length(self):
         if self.screen_length == 0:
             return 0
         else:
             num_lines_bot = self.separate_in.count('\n')+1
             return self.screen_length - num_lines_bot
 
     def init_term_title(self):
         # Enable or disable the terminal title.
         if self.term_title:
             toggle_set_term_title(True)
             set_term_title('IPython: ' + abbrev_cwd())
         else:
             toggle_set_term_title(False)
 
     #-------------------------------------------------------------------------
     # Things related to aliases
     #-------------------------------------------------------------------------
 
     def init_alias(self):
         # The parent class defines aliases that can be safely used with any
         # frontend.
         super(TerminalInteractiveShell, self).init_alias()
 
         # Now define aliases that only make sense on the terminal, because they
         # need direct access to the console in a way that we can't emulate in
         # GUI or web frontend
         if os.name == 'posix':
             aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
                        ('man', 'man')]
         elif os.name == 'nt':
             aliases = [('cls', 'cls')]
 
 
         for name, cmd in aliases:
             self.alias_manager.soft_define_alias(name, cmd)
 
     #-------------------------------------------------------------------------
     # Things related to the banner and usage
     #-------------------------------------------------------------------------
 
     def _banner1_changed(self):
         self.compute_banner()
 
     def _banner2_changed(self):
         self.compute_banner()
 
     def _term_title_changed(self, name, new_value):
         self.init_term_title()
 
     def init_banner(self, banner1, banner2, display_banner):
         if banner1 is not None:
             self.banner1 = banner1
         if banner2 is not None:
             self.banner2 = banner2
         if display_banner is not None:
             self.display_banner = display_banner
         self.compute_banner()
 
     def show_banner(self, banner=None):
         if banner is None:
             banner = self.banner
         self.write(banner)
 
     def compute_banner(self):
         self.banner = self.banner1
         if self.profile and self.profile != 'default':
             self.banner += '\nIPython profile: %s\n' % self.profile
         if self.banner2:
             self.banner += '\n' + self.banner2
 
     def init_usage(self, usage=None):
         if usage is None:
             self.usage = interactive_usage
         else:
             self.usage = usage
 
     #-------------------------------------------------------------------------
     # Mainloop and code execution logic
     #-------------------------------------------------------------------------
 
     def mainloop(self, display_banner=None):
         """Start the mainloop.
 
         If an optional banner argument is given, it will override the
         internally created default banner.
         """
 
         with self.builtin_trap, self.display_trap:
 
             while 1:
                 try:
                     self.interact(display_banner=display_banner)
                     #self.interact_with_readline()
                     # XXX for testing of a readline-decoupled repl loop, call
                     # interact_with_readline above
                     break
                 except KeyboardInterrupt:
                     # this should not be necessary, but KeyboardInterrupt
                     # handling seems rather unpredictable...
                     self.write("\nKeyboardInterrupt in interact()\n")
 
     def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
         """Store multiple lines as a single entry in history"""
 
         # do nothing without readline or disabled multiline
         if not self.has_readline or not self.multiline_history:
             return hlen_before_cell
 
         # windows rl has no remove_history_item
         if not hasattr(self.readline, "remove_history_item"):
             return hlen_before_cell
 
         # skip empty cells
         if not source_raw.rstrip():
             return hlen_before_cell
 
         # nothing changed do nothing, e.g. when rl removes consecutive dups
         hlen = self.readline.get_current_history_length()
         if hlen == hlen_before_cell:
             return hlen_before_cell
 
         for i in range(hlen - hlen_before_cell):
             self.readline.remove_history_item(hlen - i - 1)
         stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
         self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
                                     stdin_encoding))
         return self.readline.get_current_history_length()
 
     def interact(self, display_banner=None):
         """Closely emulate the interactive Python console."""
 
         # batch run -> do not interact
         if self.exit_now:
             return
 
         if display_banner is None:
             display_banner = self.display_banner
 
         if isinstance(display_banner, py3compat.string_types):
             self.show_banner(display_banner)
         elif display_banner:
             self.show_banner()
 
         more = False
 
         if self.has_readline:
             self.readline_startup_hook(self.pre_readline)
             hlen_b4_cell = self.readline.get_current_history_length()
         else:
             hlen_b4_cell = 0
         # exit_now is set by a call to %Exit or %Quit, through the
         # ask_exit callback.
 
         while not self.exit_now:
             self.hooks.pre_prompt_hook()
             if more:
                 try:
                     prompt = self.prompt_manager.render('in2')
                 except:
                     self.showtraceback()
                 if self.autoindent:
                     self.rl_do_indent = True
 
             else:
                 try:
                     prompt = self.separate_in + self.prompt_manager.render('in')
                 except:
                     self.showtraceback()
             try:
                 line = self.raw_input(prompt)
                 if self.exit_now:
                     # quick exit on sys.std[in|out] close
                     break
                 if self.autoindent:
                     self.rl_do_indent = False
 
             except KeyboardInterrupt:
                 #double-guard against keyboardinterrupts during kbdint handling
                 try:
                     self.write('\nKeyboardInterrupt\n')
                     source_raw = self.input_splitter.source_raw_reset()[1]
                     hlen_b4_cell = \
                         self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
                     more = False
                 except KeyboardInterrupt:
                     pass
             except EOFError:
                 if self.autoindent:
                     self.rl_do_indent = False
                     if self.has_readline:
                         self.readline_startup_hook(None)
                 self.write('\n')
                 self.exit()
             except bdb.BdbQuit:
                 warn('The Python debugger has exited with a BdbQuit exception.\n'
                      'Because of how pdb handles the stack, it is impossible\n'
                      'for IPython to properly format this particular exception.\n'
                      'IPython will resume normal operation.')
             except:
                 # exceptions here are VERY RARE, but they can be triggered
                 # asynchronously by signal handlers, for example.
                 self.showtraceback()
             else:
                 self.input_splitter.push(line)
                 more = self.input_splitter.push_accepts_more()
                 if (self.SyntaxTB.last_syntax_error and
                     self.autoedit_syntax):
                     self.edit_syntax_error()
                 if not more:
                     source_raw = self.input_splitter.source_raw_reset()[1]
                     self.run_cell(source_raw, store_history=True)
                     hlen_b4_cell = \
                         self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
 
         # Turn off the exit flag, so the mainloop can be restarted if desired
         self.exit_now = False
 
     def raw_input(self, prompt=''):
         """Write a prompt and read a line.
 
         The returned line does not include the trailing newline.
         When the user enters the EOF key sequence, EOFError is raised.
 
-        Optional inputs:
+        Parameters
+        ----------
 
-          - prompt(''): a string to be printed to prompt the user.
-
-          - continue_prompt(False): whether this line is the first one or a
-          continuation in a sequence of inputs.
+        prompt : str, optional
+          A string to be printed to prompt the user.
         """
         # Code run by the user may have modified the readline completer state.
         # We must ensure that our completer is back in place.
 
         if self.has_readline:
             self.set_readline_completer()
         
         # raw_input expects str, but we pass it unicode sometimes
         prompt = py3compat.cast_bytes_py2(prompt)
 
         try:
             line = py3compat.str_to_unicode(self.raw_input_original(prompt))
         except ValueError:
             warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
                  " or sys.stdout.close()!\nExiting IPython!\n")
             self.ask_exit()
             return ""
 
         # Try to be reasonably smart about not re-indenting pasted input more
         # than necessary.  We do this by trimming out the auto-indent initial
         # spaces, if the user's actual input started itself with whitespace.
         if self.autoindent:
             if num_ini_spaces(line) > self.indent_current_nsp:
                 line = line[self.indent_current_nsp:]
                 self.indent_current_nsp = 0
 
         return line
 
     #-------------------------------------------------------------------------
     # Methods to support auto-editing of SyntaxErrors.
     #-------------------------------------------------------------------------
 
     def edit_syntax_error(self):
         """The bottom half of the syntax error handler called in the main loop.
 
         Loop until syntax error is fixed or user cancels.
         """
 
         while self.SyntaxTB.last_syntax_error:
             # copy and clear last_syntax_error
             err = self.SyntaxTB.clear_err_state()
             if not self._should_recompile(err):
                 return
             try:
                 # may set last_syntax_error again if a SyntaxError is raised
                 self.safe_execfile(err.filename,self.user_ns)
             except:
                 self.showtraceback()
             else:
                 try:
                     f = open(err.filename)
                     try:
                         # This should be inside a display_trap block and I
                         # think it is.
                         sys.displayhook(f.read())
                     finally:
                         f.close()
                 except:
                     self.showtraceback()
 
     def _should_recompile(self,e):
         """Utility routine for edit_syntax_error"""
 
         if e.filename in ('<ipython console>','<input>','<string>',
                           '<console>','<BackgroundJob compilation>',
                           None):
 
             return False
         try:
             if (self.autoedit_syntax and
                 not self.ask_yes_no('Return to editor to correct syntax error? '
                               '[Y/n] ','y')):
                 return False
         except EOFError:
             return False
 
         def int0(x):
             try:
                 return int(x)
             except TypeError:
                 return 0
         # always pass integer line and offset values to editor hook
         try:
             self.hooks.fix_error_editor(e.filename,
                 int0(e.lineno),int0(e.offset),e.msg)
         except TryNext:
             warn('Could not open editor')
             return False
         return True
 
     #-------------------------------------------------------------------------
     # Things related to exiting
     #-------------------------------------------------------------------------
 
     def ask_exit(self):
         """ Ask the shell to exit. Can be overiden and used as a callback. """
         self.exit_now = True
 
     def exit(self):
         """Handle interactive exit.
 
         This method calls the ask_exit callback."""
         if self.confirm_exit:
             if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
                 self.ask_exit()
         else:
             self.ask_exit()
 
     #-------------------------------------------------------------------------
     # Things related to magics
     #-------------------------------------------------------------------------
 
     def init_magics(self):
         super(TerminalInteractiveShell, self).init_magics()
         self.register_magics(TerminalMagics)
 
     def showindentationerror(self):
         super(TerminalInteractiveShell, self).showindentationerror()
         if not self.using_paste_magics:
             print("If you want to paste code into IPython, try the "
                 "%paste and %cpaste magic functions.")
 
 
 InteractiveShellABC.register(TerminalInteractiveShell)

IPython/testing/decorators.py

@@ -1,382 +1,383 b''
 # -*- coding: utf-8 -*-
 """Decorators for labeling test objects.
 
 Decorators that merely return a modified version of the original function
 object are straightforward.  Decorators that return a new function object need
 to use nose.tools.make_decorator(original_function)(decorator) in returning the
 decorator, in order to preserve metadata such as function name, setup and
 teardown functions and so on - see nose.tools for more information.
 
 This module provides a set of useful decorators meant to be ready to use in
 your own tests.  See the bottom of the file for the ready-made ones, and if you
 find yourself writing a new one that may be of generic use, add it here.
 
 Included decorators:
 
 
 Lightweight testing that remains unittest-compatible.
 
 - An @as_unittest decorator can be used to tag any normal parameter-less
   function as a unittest TestCase.  Then, both nose and normal unittest will
   recognize it as such.  This will make it easier to migrate away from Nose if
   we ever need/want to while maintaining very lightweight tests.
 
 NOTE: This file contains IPython-specific decorators. Using the machinery in
 IPython.external.decorators, we import either numpy.testing.decorators if numpy is
 available, OR use equivalent code in IPython.external._decorators, which
 we've copied verbatim from numpy.
 
 Authors
 -------
 
 - Fernando Perez <[e-mail]>
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import sys
 import os
 import tempfile
 import unittest
 
 # Third-party imports
 
 # This is Michele Simionato's decorator module, kept verbatim.
 from IPython.external.decorator import decorator
 
 # Expose the unittest-driven decorators
 from .ipunittest import ipdoctest, ipdocstring
 
 # Grab the numpy-specific decorators which we keep in a file that we
 # occasionally update from upstream: decorators.py is a copy of
 # numpy.testing.decorators, we expose all of it here.
 from IPython.external.decorators import *
 
 # For onlyif_cmd_exists decorator
 from IPython.utils.process import is_cmd_found
 from IPython.utils.py3compat import string_types
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 # Simple example of the basic idea
 def as_unittest(func):
     """Decorator to make a simple function into a normal test via unittest."""
     class Tester(unittest.TestCase):
         def test(self):
             func()
 
     Tester.__name__ = func.__name__
 
     return Tester
 
 # Utility functions
 
 def apply_wrapper(wrapper,func):
     """Apply a wrapper to a function for decoration.
 
     This mixes Michele Simionato's decorator tool with nose's make_decorator,
     to apply a wrapper in a decorator so that all nose attributes, as well as
     function signature and other properties, survive the decoration cleanly.
     This will ensure that wrapped functions can still be well introspected via
     IPython, for example.
     """
     import nose.tools
 
     return decorator(wrapper,nose.tools.make_decorator(func)(wrapper))
 
 
 def make_label_dec(label,ds=None):
     """Factory function to create a decorator that applies one or more labels.
 
     Parameters
     ----------
       label : string or sequence
       One or more labels that will be applied by the decorator to the functions
     it decorates.  Labels are attributes of the decorated function with their
     value set to True.
 
       ds : string
       An optional docstring for the resulting decorator.  If not given, a
       default docstring is auto-generated.
 
     Returns
     -------
       A decorator.
 
     Examples
     --------
 
     A simple labeling decorator:
 
     >>> slow = make_label_dec('slow')
     >>> slow.__doc__
     "Labels a test as 'slow'."
     
     And one that uses multiple labels and a custom docstring:
     
     >>> rare = make_label_dec(['slow','hard'],
     ... "Mix labels 'slow' and 'hard' for rare tests.")
     >>> rare.__doc__
     "Mix labels 'slow' and 'hard' for rare tests."
 
     Now, let's test using this one:
     >>> @rare
     ... def f(): pass
     ...
     >>>
     >>> f.slow
     True
     >>> f.hard
     True
     """
 
     if isinstance(label, string_types):
         labels = [label]
     else:
         labels = label
 
     # Validate that the given label(s) are OK for use in setattr() by doing a
     # dry run on a dummy function.
     tmp = lambda : None
     for label in labels:
         setattr(tmp,label,True)
 
     # This is the actual decorator we'll return
     def decor(f):
         for label in labels:
             setattr(f,label,True)
         return f
 
     # Apply the user's docstring, or autogenerate a basic one
     if ds is None:
         ds = "Labels a test as %r." % label
     decor.__doc__ = ds
 
     return decor
 
 
 # Inspired by numpy's skipif, but uses the full apply_wrapper utility to
 # preserve function metadata better and allows the skip condition to be a
 # callable.
 def skipif(skip_condition, msg=None):
     ''' Make function raise SkipTest exception if skip_condition is true
 
     Parameters
     ----------
-    skip_condition : bool or callable.
+
+    skip_condition : bool or callable
         Flag to determine whether to skip test.  If the condition is a
         callable, it is used at runtime to dynamically make the decision.  This
         is useful for tests that may require costly imports, to delay the cost
         until the test suite is actually executed.
     msg : string
-        Message to give on raising a SkipTest exception
+      Message to give on raising a SkipTest exception.
 
    Returns
    -------
    decorator : function
        Decorator, which, when applied to a function, causes SkipTest
        to be raised when the skip_condition was True, and the function
        to be called normally otherwise.
 
     Notes
     -----
     You will see from the code that we had to further decorate the
     decorator with the nose.tools.make_decorator function in order to
     transmit function name, and various other metadata.
     '''
 
     def skip_decorator(f):
         # Local import to avoid a hard nose dependency and only incur the
         # import time overhead at actual test-time.
         import nose
 
         # Allow for both boolean or callable skip conditions.
         if callable(skip_condition):
             skip_val = skip_condition
         else:
             skip_val = lambda : skip_condition
 
         def get_msg(func,msg=None):
             """Skip message with information about function being skipped."""
             if msg is None: out = 'Test skipped due to test condition.'
             else: out = msg
             return "Skipping test: %s. %s" % (func.__name__,out)
 
         # We need to define *two* skippers because Python doesn't allow both
         # return with value and yield inside the same function.
         def skipper_func(*args, **kwargs):
             """Skipper for normal test functions."""
             if skip_val():
                 raise nose.SkipTest(get_msg(f,msg))
             else:
                 return f(*args, **kwargs)
 
         def skipper_gen(*args, **kwargs):
             """Skipper for test generators."""
             if skip_val():
                 raise nose.SkipTest(get_msg(f,msg))
             else:
                 for x in f(*args, **kwargs):
                     yield x
 
         # Choose the right skipper to use when building the actual generator.
         if nose.util.isgenerator(f):
             skipper = skipper_gen
         else:
             skipper = skipper_func
 
         return nose.tools.make_decorator(f)(skipper)
 
     return skip_decorator
 
 # A version with the condition set to true, common case just to attach a message
 # to a skip decorator
 def skip(msg=None):
     """Decorator factory - mark a test function for skipping from test suite.
 
     Parameters
     ----------
       msg : string
         Optional message to be added.
 
     Returns
     -------
        decorator : function
          Decorator, which, when applied to a function, causes SkipTest
          to be raised, with the optional message added.
       """
 
     return skipif(True,msg)
 
 
 def onlyif(condition, msg):
     """The reverse from skipif, see skipif for details."""
 
     if callable(condition):
         skip_condition = lambda : not condition()
     else:
         skip_condition = lambda : not condition
 
     return skipif(skip_condition, msg)
 
 #-----------------------------------------------------------------------------
 # Utility functions for decorators
 def module_not_available(module):
     """Can module be imported?  Returns true if module does NOT import.
 
     This is used to make a decorator to skip tests that require module to be
     available, but delay the 'import numpy' to test execution time.
     """
     try:
         mod = __import__(module)
         mod_not_avail = False
     except ImportError:
         mod_not_avail = True
 
     return mod_not_avail
 
 
 def decorated_dummy(dec, name):
     """Return a dummy function decorated with dec, with the given name.
     
     Examples
     --------
     import IPython.testing.decorators as dec
     setup = dec.decorated_dummy(dec.skip_if_no_x11, __name__)
     """
     dummy = lambda: None
     dummy.__name__ = name
     return dec(dummy)
 
 #-----------------------------------------------------------------------------
 # Decorators for public use
 
 # Decorators to skip certain tests on specific platforms.
 skip_win32 = skipif(sys.platform == 'win32',
                     "This test does not run under Windows")
 skip_linux = skipif(sys.platform.startswith('linux'),
                     "This test does not run under Linux")
 skip_osx = skipif(sys.platform == 'darwin',"This test does not run under OS X")
 
 
 # Decorators to skip tests if not on specific platforms.
 skip_if_not_win32 = skipif(sys.platform != 'win32',
                            "This test only runs under Windows")
 skip_if_not_linux = skipif(not sys.platform.startswith('linux'),
                            "This test only runs under Linux")
 skip_if_not_osx = skipif(sys.platform != 'darwin',
                          "This test only runs under OSX")
 
 
 _x11_skip_cond = (sys.platform not in ('darwin', 'win32') and
                   os.environ.get('DISPLAY', '') == '')
 _x11_skip_msg = "Skipped under *nix when X11/XOrg not available"
 
 skip_if_no_x11 = skipif(_x11_skip_cond, _x11_skip_msg)
 
 # not a decorator itself, returns a dummy function to be used as setup
 def skip_file_no_x11(name):
     return decorated_dummy(skip_if_no_x11, name) if _x11_skip_cond else None
 
 # Other skip decorators
 
 # generic skip without module
 skip_without = lambda mod: skipif(module_not_available(mod), "This test requires %s" % mod)
 
 skipif_not_numpy = skip_without('numpy')
 
 skipif_not_matplotlib = skip_without('matplotlib')
 
 skipif_not_sympy = skip_without('sympy')
 
 skip_known_failure = knownfailureif(True,'This test is known to fail')
 
 known_failure_py3 = knownfailureif(sys.version_info[0] >= 3, 
                                     'This test is known to fail on Python 3.')
 
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions
 null_deco = lambda f: f
 
 # Some tests only run where we can use unicode paths. Note that we can't just
 # check os.path.supports_unicode_filenames, which is always False on Linux.
 try:
     f = tempfile.NamedTemporaryFile(prefix=u"tmp€")
 except UnicodeEncodeError:
     unicode_paths = False
 else:
     unicode_paths = True
     f.close()
 
 onlyif_unicode_paths = onlyif(unicode_paths, ("This test is only applicable "
                                     "where we can use unicode in filenames."))
 
 
 def onlyif_cmds_exist(*commands):
     """
     Decorator to skip test when at least one of `commands` is not found.
     """
     for cmd in commands:
         try:
             if not is_cmd_found(cmd):
                 return skip("This test runs only if command '{0}' "
                             "is installed".format(cmd))
         except ImportError as e:
             # is_cmd_found uses pywin32 on windows, which might not be available
             if sys.platform == 'win32' and 'pywin32' in str(e):
                 return skip("This test runs only if pywin32 and command '{0}' "
                             "is installed".format(cmd))
             raise e
     return null_deco

docs/source/whatsnew/github-stats-0.12.rst

@@ -1,621 +1,621 b''
 .. _issues_list_012:
 
 Issues closed in the 0.12 development cycle
 ===========================================
 
 Issues closed in 0.12.1
 -----------------------
 
 GitHub stats for bugfix release 0.12.1 (12/28/2011-04/16/2012), backporting
 pull requests from 0.13.
 
 We closed a total of 71 issues: 44 pull requests and 27 issues; this is the
 full list (generated with the script `tools/github_stats.py`).
 
 This list is automatically generated, and may be incomplete:
 
 Pull Requests (44):
 
 * :ghpull:`1175`: core.completer: Clean up excessive and unused code.
 * :ghpull:`1187`: misc notebook: connection file cleanup, first heartbeat, startup flush
 * :ghpull:`1190`: Fix link to Chris Fonnesbeck blog post about 0.11 highlights.
 * :ghpull:`1196`: docs: looks like a file path might have been accidentally pasted in the middle of a word
 * :ghpull:`1206`: don't preserve fixConsole output in json
 * :ghpull:`1207`: fix loadpy duplicating newlines
 * :ghpull:`1213`: BUG: Minor typo in history_console_widget.py
 * :ghpull:`1218`: Added -q option to %prun for suppression of the output, along with editing the dochelp string.
 * :ghpull:`1222`: allow Reference as callable in map/apply
 * :ghpull:`1229`: Fix display of SyntaxError in Python 3
 * :ghpull:`1246`: Skip tests that require X, when importing pylab results in RuntimeError.
 * :ghpull:`1253`: set auto_create flag for notebook apps
 * :ghpull:`1257`: use self.kernel_manager_class in qtconsoleapp
 * :ghpull:`1262`: Heartbeat no longer shares the app's Context
 * :ghpull:`1283`: HeartMonitor.period should be an Integer
 * :ghpull:`1284`: a fix for GH 1269
 * :ghpull:`1289`: Make autoreload extension work on Python 3.
 * :ghpull:`1306`: Fix %prun input parsing for escaped characters (closes #1302)
 * :ghpull:`1312`: minor heartbeat tweaks
 * :ghpull:`1318`: make Ctrl-D in qtconsole act same as in terminal (ready to merge)
 * :ghpull:`1341`: Don't attempt to tokenize binary files for tracebacks
 * :ghpull:`1353`: Save notebook as script using unicode file handle.
 * :ghpull:`1363`: Fix some minor color/style config issues in the qtconsole
 * :ghpull:`1364`: avoid jsonlib returning Decimal
 * :ghpull:`1369`: load header with engine id when engine dies in TaskScheduler
 * :ghpull:`1370`: allow draft76 websockets (Safari)
 * :ghpull:`1374`: remove calls to meaningless ZMQStream.on_err
 * :ghpull:`1377`: Saving non-ascii history
 * :ghpull:`1396`: Fix for %tb magic.
 * :ghpull:`1402`: fix symlinked /home issue for FreeBSD
 * :ghpull:`1413`: get_home_dir expands symlinks, adjust test accordingly
 * :ghpull:`1414`: ignore errors in shell.var_expand
 * :ghpull:`1430`: Fix for tornado check for tornado < 1.1.0
 * :ghpull:`1445`: Don't build sphinx docs for sdists
 * :ghpull:`1463`: Fix completion when importing modules in the cwd.
 * :ghpull:`1477`: fix dangling `buffer` in IPython.parallel.util
 * :ghpull:`1495`: BUG: Fix pretty-printing for overzealous objects
 * :ghpull:`1496`: BUG: LBYL when clearing the output history on shutdown.
 * :ghpull:`1514`: DOC: Fix references to IPython.lib.pretty instead of the old location
 * :ghpull:`1517`: Fix indentation bug in IPython/lib/pretty.py
 * :ghpull:`1538`: store git commit hash in utils._sysinfo instead of hidden data file
 * :ghpull:`1599`: Fix for %run -d in Python 3
 * :ghpull:`1602`: Fix %env for Python 3
 * :ghpull:`1607`: cleanup sqlitedb temporary db file after tests
 
 Issues (27):
 
 * :ghissue:`676`: IPython.embed() from ipython crashes twice on exit
 * :ghissue:`846`: Autoreload extension doesn't work with Python 3.2
 * :ghissue:`1187`: misc notebook: connection file cleanup, first heartbeat, startup flush
 * :ghissue:`1191`: profile/startup files not executed with "notebook"
 * :ghissue:`1197`: Interactive shell trying to: from ... import history
 * :ghissue:`1198`: Kernel Has Died error in Notebook
 * :ghissue:`1201`: %env magic fails with Python 3.2
 * :ghissue:`1204`: double newline from %loadpy in python notebook (at least on mac)
 * :ghissue:`1208`: should dv.sync_import print failed imports ?
 * :ghissue:`1225`: SyntaxError display broken in Python 3
 * :ghissue:`1232`: Dead kernel loop
 * :ghissue:`1241`: When our debugger class is used standalone `_oh` key errors are thrown
 * :ghissue:`1254`: typo in notebooklist.js breaks links
 * :ghissue:`1260`: heartbeat failure on long gil-holding operation
 * :ghissue:`1268`: notebook %reset magic fails with StdinNotImplementedError
 * :ghissue:`1269`: Another strange input handling error
 * :ghissue:`1281`: in Hub: registration_timeout must be an integer, but heartmonitor.period is CFloat
 * :ghissue:`1302`: Input parsing with %prun clobbers escapes
 * :ghissue:`1304`: controller/server load can disrupt heartbeat
 * :ghissue:`1317`: Very slow traceback construction from Cython extension
 * :ghissue:`1345`: notebook can't save unicode as script
 * :ghissue:`1375`: %history -g -f file encoding issue
 * :ghissue:`1401`: numpy arrays cannot be used with View.apply() in Python 3
 * :ghissue:`1408`: test_get_home_dir_3 failed on Mac OS X
 * :ghissue:`1412`: Input parsing issue with %prun
 * :ghissue:`1421`: ipython32 %run -d breaks with NameError name 'execfile' is not defined
 * :ghissue:`1484`: unhide .git_commit_info.ini
 
 
 Issues closed in 0.12
 ---------------------
 
 In this cycle, from August 1 to December 28 2011, we closed a total of 515
 issues, 257 pull requests and 258 regular issues; this is the full list
 (generated with the script `tools/github_stats.py`).
 
 Pull requests (257):
 
 * `1174 <https://github.com/ipython/ipython/issues/1174>`_: Remove %install_default_config and %install_profiles
 * `1178 <https://github.com/ipython/ipython/issues/1178>`_: Correct string type casting in pinfo.
 * `1096 <https://github.com/ipython/ipython/issues/1096>`_: Show class init and call tooltips in notebook
 * `1176 <https://github.com/ipython/ipython/issues/1176>`_: Modifications to profile list
 * `1173 <https://github.com/ipython/ipython/issues/1173>`_: don't load gui/pylab in console frontend
 * `1168 <https://github.com/ipython/ipython/issues/1168>`_: Add --script flag as shorthand for notebook save_script option.
 * `1165 <https://github.com/ipython/ipython/issues/1165>`_: encode image_tag as utf8 in [x]html export
 * `1161 <https://github.com/ipython/ipython/issues/1161>`_: Allow %loadpy to load remote URLs that don't end in .py
 * `1158 <https://github.com/ipython/ipython/issues/1158>`_: Add coding header when notebook exported to .py file.
 * `1160 <https://github.com/ipython/ipython/issues/1160>`_: don't ignore ctrl-C during `%gui qt`
 * `1159 <https://github.com/ipython/ipython/issues/1159>`_: Add encoding header to Python files downloaded from notebooks.
 * `1155 <https://github.com/ipython/ipython/issues/1155>`_: minor post-execute fixes (#1154)
 * `1153 <https://github.com/ipython/ipython/issues/1153>`_: Pager tearing bug
 * `1152 <https://github.com/ipython/ipython/issues/1152>`_: Add support for displaying maptlotlib axes directly.
 * `1079 <https://github.com/ipython/ipython/issues/1079>`_: Login/out button cleanups
 * `1151 <https://github.com/ipython/ipython/issues/1151>`_: allow access to user_ns in prompt_manager
 * `1120 <https://github.com/ipython/ipython/issues/1120>`_: updated vim-ipython (pending)
 * `1150 <https://github.com/ipython/ipython/issues/1150>`_: BUG: Scrolling pager in vsplit on Mac OSX tears.
 * `1149 <https://github.com/ipython/ipython/issues/1149>`_: #1148 (win32 arg_split)
 * `1147 <https://github.com/ipython/ipython/issues/1147>`_: Put qtconsole forground when launching
 * `1146 <https://github.com/ipython/ipython/issues/1146>`_: allow saving notebook.py next to notebook.ipynb
 * `1128 <https://github.com/ipython/ipython/issues/1128>`_: fix pylab StartMenu item
 * `1140 <https://github.com/ipython/ipython/issues/1140>`_: Namespaces for embedding
 * `1132 <https://github.com/ipython/ipython/issues/1132>`_: [notebook] read-only: disable name field
 * `1125 <https://github.com/ipython/ipython/issues/1125>`_: notebook : update logo
 * `1135 <https://github.com/ipython/ipython/issues/1135>`_: allow customized template and static file paths for the notebook web app
 * `1122 <https://github.com/ipython/ipython/issues/1122>`_: BUG: Issue #755 qt IPythonWidget.execute_file fails if filename contains...
 * `1137 <https://github.com/ipython/ipython/issues/1137>`_: rename MPIExecLaunchers to MPILaunchers
 * `1130 <https://github.com/ipython/ipython/issues/1130>`_: optionally ignore  shlex's ValueError in arg_split
 * `1116 <https://github.com/ipython/ipython/issues/1116>`_: Shlex unicode
 * `1073 <https://github.com/ipython/ipython/issues/1073>`_: Storemagic plugin
 * `1143 <https://github.com/ipython/ipython/issues/1143>`_: Add post_install script to create start menu entries in Python 3
 * `1138 <https://github.com/ipython/ipython/issues/1138>`_: Fix tests to work when ~/.config/ipython contains a symlink.
 * `1121 <https://github.com/ipython/ipython/issues/1121>`_: Don't transform function calls on IPyAutocall objects
 * `1118 <https://github.com/ipython/ipython/issues/1118>`_: protect CRLF from carriage-return action
 * `1105 <https://github.com/ipython/ipython/issues/1105>`_: Fix for prompts containing newlines.
 * `1126 <https://github.com/ipython/ipython/issues/1126>`_: Totally remove pager when read only (notebook)
 * `1091 <https://github.com/ipython/ipython/issues/1091>`_: qtconsole : allow copy with shortcut in pager
 * `1114 <https://github.com/ipython/ipython/issues/1114>`_: fix magics history in two-process ipython console
-* `1113 <https://github.com/ipython/ipython/issues/1113>`_: Fixing #1112 removing failing asserts for test_carriage_return and test_...
+* `1113 <https://github.com/ipython/ipython/issues/1113>`_: Fixing #1112 removing failing asserts for test_carriage_return and test_beep
 * `1089 <https://github.com/ipython/ipython/issues/1089>`_: Support carriage return ('\r') and beep ('\b') characters in the qtconsole
 * `1108 <https://github.com/ipython/ipython/issues/1108>`_: Completer usability 2 (rebased of  pr #1082)
 * `864 <https://github.com/ipython/ipython/issues/864>`_: Two-process terminal frontend (ipython core branch)
 * `1082 <https://github.com/ipython/ipython/issues/1082>`_: usability and cross browser compat for completer
 * `1053 <https://github.com/ipython/ipython/issues/1053>`_: minor improvements to text placement in qtconsole
 * `1106 <https://github.com/ipython/ipython/issues/1106>`_: Fix display of errors in compiled code on Python 3
 * `1077 <https://github.com/ipython/ipython/issues/1077>`_: allow the notebook to run without MathJax
 * `1072 <https://github.com/ipython/ipython/issues/1072>`_: If object has a getdoc() method, override its normal docstring.
 * `1059 <https://github.com/ipython/ipython/issues/1059>`_: Switch to simple `__IPYTHON__` global
 * `1070 <https://github.com/ipython/ipython/issues/1070>`_: Execution count after SyntaxError
 * `1098 <https://github.com/ipython/ipython/issues/1098>`_: notebook: config section UI
 * `1101 <https://github.com/ipython/ipython/issues/1101>`_: workaround spawnb missing from pexpect.__all__
 * `1097 <https://github.com/ipython/ipython/issues/1097>`_: typo, should fix #1095
 * `1099 <https://github.com/ipython/ipython/issues/1099>`_: qtconsole export xhtml/utf8
 * `1083 <https://github.com/ipython/ipython/issues/1083>`_: Prompts
 * `1081 <https://github.com/ipython/ipython/issues/1081>`_: Fix wildcard search for updated namespaces
 * `1084 <https://github.com/ipython/ipython/issues/1084>`_: write busy in notebook window title...
 * `1078 <https://github.com/ipython/ipython/issues/1078>`_: PromptManager fixes
 * `1064 <https://github.com/ipython/ipython/issues/1064>`_: Win32 shlex
 * `1069 <https://github.com/ipython/ipython/issues/1069>`_: As you type completer, fix on Firefox
 * `1039 <https://github.com/ipython/ipython/issues/1039>`_: Base of an as you type completer.
 * `1065 <https://github.com/ipython/ipython/issues/1065>`_: Qtconsole fix racecondition
 * `507 <https://github.com/ipython/ipython/issues/507>`_: Prompt manager
 * `1056 <https://github.com/ipython/ipython/issues/1056>`_: Warning in code. qtconsole ssh -X
 * `1036 <https://github.com/ipython/ipython/issues/1036>`_: Clean up javascript based on js2-mode feedback.
 * `1052 <https://github.com/ipython/ipython/issues/1052>`_: Pylab fix
 * `648 <https://github.com/ipython/ipython/issues/648>`_: Usermod
 * `969 <https://github.com/ipython/ipython/issues/969>`_: Pexpect-u
 * `1007 <https://github.com/ipython/ipython/issues/1007>`_: Fix paste/cpaste bug and refactor/cleanup that code a lot.
 * `506 <https://github.com/ipython/ipython/issues/506>`_: make ENTER on a previous input field replace current input buffer
 * `1040 <https://github.com/ipython/ipython/issues/1040>`_: json/jsonapi cleanup
 * `1042 <https://github.com/ipython/ipython/issues/1042>`_: fix firefox (windows) break line on empty prompt number
 * `1015 <https://github.com/ipython/ipython/issues/1015>`_: emacs freezes when tab is hit in ipython with latest python-mode
 * `1023 <https://github.com/ipython/ipython/issues/1023>`_: flush stdout/stderr at the end of kernel init
 * `956 <https://github.com/ipython/ipython/issues/956>`_: Generate "All magics..." menu live
 * `1038 <https://github.com/ipython/ipython/issues/1038>`_: Notebook: don't change cell when selecting code using shift+up/down.
 * `987 <https://github.com/ipython/ipython/issues/987>`_: Add Tooltip to notebook.
 * `1028 <https://github.com/ipython/ipython/issues/1028>`_: Cleaner minimum version comparison 
 * `998 <https://github.com/ipython/ipython/issues/998>`_: defer to stdlib for path.get_home_dir()
 * `1033 <https://github.com/ipython/ipython/issues/1033>`_: update copyright to 2011/20xx-2011
 * `1032 <https://github.com/ipython/ipython/issues/1032>`_: Intercept <esc> avoid closing websocket on Firefox
 * `1030 <https://github.com/ipython/ipython/issues/1030>`_: use pyzmq tools where appropriate
 * `1029 <https://github.com/ipython/ipython/issues/1029>`_: Restore pspersistence, including %store magic, as an extension.
 * `1025 <https://github.com/ipython/ipython/issues/1025>`_: Dollar escape
 * `999 <https://github.com/ipython/ipython/issues/999>`_: Fix issue #880 - more useful message to user when %paste fails
 * `938 <https://github.com/ipython/ipython/issues/938>`_: changes to get ipython.el to work with the latest python-mode.el
 * `1012 <https://github.com/ipython/ipython/issues/1012>`_: Add logout button.
 * `1020 <https://github.com/ipython/ipython/issues/1020>`_: Dollar formatter for ! shell calls
 * `1019 <https://github.com/ipython/ipython/issues/1019>`_: Use repr() to make quoted strings
 * `1008 <https://github.com/ipython/ipython/issues/1008>`_: don't use crash_handler by default
 * `1003 <https://github.com/ipython/ipython/issues/1003>`_: Drop consecutive duplicates when refilling readline history
 * `997 <https://github.com/ipython/ipython/issues/997>`_: don't unregister interrupted post-exec functions
 * `996 <https://github.com/ipython/ipython/issues/996>`_: add Integer traitlet
 * `1016 <https://github.com/ipython/ipython/issues/1016>`_: Fix password hashing for Python 3
 * `1014 <https://github.com/ipython/ipython/issues/1014>`_: escape minus signs in manpages
 * `1013 <https://github.com/ipython/ipython/issues/1013>`_: [NumPyExampleDocstring] link was pointing to raw file
 * `1011 <https://github.com/ipython/ipython/issues/1011>`_: Add hashed password support.
 * `1005 <https://github.com/ipython/ipython/issues/1005>`_: Quick fix for os.system requiring str parameter
 * `994 <https://github.com/ipython/ipython/issues/994>`_: Allow latex formulas in HTML output
 * `955 <https://github.com/ipython/ipython/issues/955>`_: Websocket Adjustments
 * `979 <https://github.com/ipython/ipython/issues/979>`_: use system_raw in terminal, even on Windows
 * `989 <https://github.com/ipython/ipython/issues/989>`_: fix arguments for commands in _process_posix
 * `991 <https://github.com/ipython/ipython/issues/991>`_: Show traceback, continuing to start kernel if pylab init fails
 * `981 <https://github.com/ipython/ipython/issues/981>`_: Split likely multiline text when writing JSON notebooks
 * `957 <https://github.com/ipython/ipython/issues/957>`_: allow change of png DPI in inline backend
 * `968 <https://github.com/ipython/ipython/issues/968>`_: add wantDirectory to ipdoctest, so that directories will be checked for e
 * `984 <https://github.com/ipython/ipython/issues/984>`_: Do not expose variables defined at startup to %who etc.
 * `985 <https://github.com/ipython/ipython/issues/985>`_: Fixes for parallel code on Python 3
 * `963 <https://github.com/ipython/ipython/issues/963>`_: disable calltips in PySide < 1.0.7 to prevent segfault
 * `976 <https://github.com/ipython/ipython/issues/976>`_: Getting started on what's new
 * `929 <https://github.com/ipython/ipython/issues/929>`_: Multiline history
 * `964 <https://github.com/ipython/ipython/issues/964>`_: Default profile
 * `961 <https://github.com/ipython/ipython/issues/961>`_: Disable the pager for the test suite
 * `953 <https://github.com/ipython/ipython/issues/953>`_: Physics extension
 * `950 <https://github.com/ipython/ipython/issues/950>`_: Add directory for startup files
 * `940 <https://github.com/ipython/ipython/issues/940>`_: allow setting HistoryManager.hist_file with config
 * `948 <https://github.com/ipython/ipython/issues/948>`_: Monkeypatch Tornado 2.1.1 so it works with Google Chrome 16.
 * `916 <https://github.com/ipython/ipython/issues/916>`_: Run p ( https://github.com/ipython/ipython/pull/901 )
 * `923 <https://github.com/ipython/ipython/issues/923>`_: %config magic
 * `920 <https://github.com/ipython/ipython/issues/920>`_: unordered iteration of AsyncMapResults (+ a couple fixes)
 * `941 <https://github.com/ipython/ipython/issues/941>`_: Follow-up to 387dcd6a, `_rl.__doc__` is `None` with pyreadline
 * `931 <https://github.com/ipython/ipython/issues/931>`_: read-only notebook mode
 * `921 <https://github.com/ipython/ipython/issues/921>`_: Show invalid config message on TraitErrors during init
 * `815 <https://github.com/ipython/ipython/issues/815>`_: Fix #481 using custom qt4 input hook
 * `936 <https://github.com/ipython/ipython/issues/936>`_: Start webbrowser in a thread.  Prevents lockup with Chrome.
 * `937 <https://github.com/ipython/ipython/issues/937>`_: add dirty trick for readline import on OSX
 * `913 <https://github.com/ipython/ipython/issues/913>`_: Py3 tests2
 * `933 <https://github.com/ipython/ipython/issues/933>`_: Cancel in qt console closeevent should trigger event.ignore()
 * `930 <https://github.com/ipython/ipython/issues/930>`_: read-only notebook mode
 * `910 <https://github.com/ipython/ipython/issues/910>`_: Make import checks more explicit in %whos
 * `926 <https://github.com/ipython/ipython/issues/926>`_: reincarnate -V cmdline option
 * `928 <https://github.com/ipython/ipython/issues/928>`_: BUG: Set context for font size change shortcuts in ConsoleWidget
 * `901 <https://github.com/ipython/ipython/issues/901>`_:   - There is a bug when running the profiler in the magic command (prun) with python3
 * `912 <https://github.com/ipython/ipython/issues/912>`_: Add magic for cls on windows. Fix for #181.
 * `905 <https://github.com/ipython/ipython/issues/905>`_: enable %gui/%pylab magics in the Kernel
 * `909 <https://github.com/ipython/ipython/issues/909>`_: Allow IPython to run without sqlite3
 * `887 <https://github.com/ipython/ipython/issues/887>`_: Qtconsole menu
 * `895 <https://github.com/ipython/ipython/issues/895>`_: notebook download implies save
 * `896 <https://github.com/ipython/ipython/issues/896>`_: Execfile
 * `899 <https://github.com/ipython/ipython/issues/899>`_: Brian's Notebook work
 * `892 <https://github.com/ipython/ipython/issues/892>`_: don't close figures every cycle with inline matplotlib backend
 * `893 <https://github.com/ipython/ipython/issues/893>`_: Adding clear_output to kernel and HTML notebook
 * `789 <https://github.com/ipython/ipython/issues/789>`_: Adding clear_output to kernel and HTML notebook.
 * `898 <https://github.com/ipython/ipython/issues/898>`_: Don't pass unicode sys.argv with %run or `ipython script.py`
 * `897 <https://github.com/ipython/ipython/issues/897>`_: Add tooltips to the notebook via 'title' attr.
 * `877 <https://github.com/ipython/ipython/issues/877>`_: partial fix for issue #678
 * `838 <https://github.com/ipython/ipython/issues/838>`_: reenable multiline history for terminals
 * `872 <https://github.com/ipython/ipython/issues/872>`_: The constructor of Client() checks for AssertionError in validate_url to open a file instead of connection to a URL if it fails.
 * `884 <https://github.com/ipython/ipython/issues/884>`_: Notebook usability fixes
 * `883 <https://github.com/ipython/ipython/issues/883>`_: User notification if notebook saving fails
 * `889 <https://github.com/ipython/ipython/issues/889>`_: Add drop_by_id method to shell, to remove variables added by extensions.
 * `891 <https://github.com/ipython/ipython/issues/891>`_: Ability to open the notebook in a browser when it starts
 * `813 <https://github.com/ipython/ipython/issues/813>`_: Create menu bar for qtconsole
 * `876 <https://github.com/ipython/ipython/issues/876>`_: protect IPython from bad custom exception handlers
 * `856 <https://github.com/ipython/ipython/issues/856>`_: Backgroundjobs
 * `868 <https://github.com/ipython/ipython/issues/868>`_: Warn user if MathJax can't be fetched from notebook closes #744
 * `878 <https://github.com/ipython/ipython/issues/878>`_: store_history=False default for run_cell
 * `824 <https://github.com/ipython/ipython/issues/824>`_: History access
 * `850 <https://github.com/ipython/ipython/issues/850>`_: Update codemirror to 2.15 and make the code internally more version-agnostic
 * `861 <https://github.com/ipython/ipython/issues/861>`_: Fix for issue #56
 * `819 <https://github.com/ipython/ipython/issues/819>`_: Adding -m option to %run, similar to -m for python interpreter.
 * `855 <https://github.com/ipython/ipython/issues/855>`_: promote aliases and flags, to ensure they have priority over config files
 * `862 <https://github.com/ipython/ipython/issues/862>`_: BUG: Completion widget position and pager focus.
 * `847 <https://github.com/ipython/ipython/issues/847>`_: Allow connection to kernels by files
 * `708 <https://github.com/ipython/ipython/issues/708>`_: Two-process terminal frontend
 * `857 <https://github.com/ipython/ipython/issues/857>`_: make sdist flags work again (e.g. --manifest-only)
 * `835 <https://github.com/ipython/ipython/issues/835>`_: Add Tab key to list of keys that scroll down the paging widget.
 * `859 <https://github.com/ipython/ipython/issues/859>`_: Fix for issue #800
 * `848 <https://github.com/ipython/ipython/issues/848>`_: Python3 setup.py install failiure
 * `845 <https://github.com/ipython/ipython/issues/845>`_: Tests on Python 3
 * `802 <https://github.com/ipython/ipython/issues/802>`_: DOC: extensions: add documentation for the bundled extensions
 * `830 <https://github.com/ipython/ipython/issues/830>`_: contiguous stdout/stderr in notebook
 * `761 <https://github.com/ipython/ipython/issues/761>`_: Windows: test runner fails if repo path (e.g. home dir) contains spaces
 * `801 <https://github.com/ipython/ipython/issues/801>`_: Py3 notebook
 * `809 <https://github.com/ipython/ipython/issues/809>`_: use CFRunLoop directly in `ipython kernel --pylab osx`
 * `841 <https://github.com/ipython/ipython/issues/841>`_: updated old scipy.org links, other minor doc fixes
 * `837 <https://github.com/ipython/ipython/issues/837>`_: remove all trailling spaces
 * `834 <https://github.com/ipython/ipython/issues/834>`_: Issue https://github.com/ipython/ipython/issues/832 resolution
 * `746 <https://github.com/ipython/ipython/issues/746>`_: ENH: extensions: port autoreload to current API
 * `828 <https://github.com/ipython/ipython/issues/828>`_: fixed permissions (sub-modules should not be executable) + added shebang  for run_ipy_in_profiler.py
 * `798 <https://github.com/ipython/ipython/issues/798>`_: pexpect & Python 3
 * `804 <https://github.com/ipython/ipython/issues/804>`_: Magic 'range' crash if greater than len(input_hist)
 * `821 <https://github.com/ipython/ipython/issues/821>`_: update tornado dependency to 2.1
 * `807 <https://github.com/ipython/ipython/issues/807>`_: Faciliate ssh tunnel sharing by announcing ports
 * `795 <https://github.com/ipython/ipython/issues/795>`_: Add cluster-id for multiple cluster instances per profile
 * `742 <https://github.com/ipython/ipython/issues/742>`_: Glut
 * `668 <https://github.com/ipython/ipython/issues/668>`_: Greedy completer
 * `776 <https://github.com/ipython/ipython/issues/776>`_: Reworking qtconsole shortcut, add fullscreen
 * `790 <https://github.com/ipython/ipython/issues/790>`_: TST: add future unicode_literals test (#786)
 * `775 <https://github.com/ipython/ipython/issues/775>`_: redirect_in/redirect_out should be constrained to windows only
 * `793 <https://github.com/ipython/ipython/issues/793>`_: Don't use readline in the ZMQShell
 * `743 <https://github.com/ipython/ipython/issues/743>`_: Pyglet
 * `774 <https://github.com/ipython/ipython/issues/774>`_: basic/initial .mailmap for nice shortlog summaries
 * `770 <https://github.com/ipython/ipython/issues/770>`_: #769 (reopened)
 * `784 <https://github.com/ipython/ipython/issues/784>`_: Parse user code to AST using compiler flags.
 * `783 <https://github.com/ipython/ipython/issues/783>`_: always use StringIO, never cStringIO
 * `782 <https://github.com/ipython/ipython/issues/782>`_: flush stdout/stderr on displayhook call
 * `622 <https://github.com/ipython/ipython/issues/622>`_: Make pylab import all configurable 
 * `745 <https://github.com/ipython/ipython/issues/745>`_: Don't assume history requests succeed in qtconsole
 * `725 <https://github.com/ipython/ipython/issues/725>`_: don't assume cursor.selectedText() is a string
 * `778 <https://github.com/ipython/ipython/issues/778>`_: don't override execfile on Python 2
 * `663 <https://github.com/ipython/ipython/issues/663>`_: Python 3 compatilibility work
 * `762 <https://github.com/ipython/ipython/issues/762>`_: qtconsole ipython widget's execute_file fails if filename contains spaces or quotes
 * `763 <https://github.com/ipython/ipython/issues/763>`_: Set context for shortcuts in ConsoleWidget
 * `722 <https://github.com/ipython/ipython/issues/722>`_: PyPy compatibility
 * `757 <https://github.com/ipython/ipython/issues/757>`_: ipython.el is broken in 0.11
 * `764 <https://github.com/ipython/ipython/issues/764>`_: fix "--colors=<color>" option in py-python-command-args.
 * `758 <https://github.com/ipython/ipython/issues/758>`_: use ROUTER/DEALER socket names instead of XREP/XREQ
 * `736 <https://github.com/ipython/ipython/issues/736>`_: enh: added authentication ability for webapp
 * `748 <https://github.com/ipython/ipython/issues/748>`_: Check for tornado before running frontend.html tests.
 * `754 <https://github.com/ipython/ipython/issues/754>`_: restore msg_id/msg_type aliases in top level of msg dict
 * `769 <https://github.com/ipython/ipython/issues/769>`_: Don't treat bytes objects as json-safe
 * `753 <https://github.com/ipython/ipython/issues/753>`_: DOC: msg['msg_type'] removed
 * `766 <https://github.com/ipython/ipython/issues/766>`_: fix "--colors=<color>" option in py-python-command-args.
 * `765 <https://github.com/ipython/ipython/issues/765>`_: fix "--colors=<color>" option in py-python-command-args.
 * `741 <https://github.com/ipython/ipython/issues/741>`_: Run PyOs_InputHook in pager to keep plot windows interactive.
 * `664 <https://github.com/ipython/ipython/issues/664>`_: Remove ipythonrc references from documentation
 * `750 <https://github.com/ipython/ipython/issues/750>`_: Tiny doc fixes
 * `433 <https://github.com/ipython/ipython/issues/433>`_: ZMQ terminal frontend
 * `734 <https://github.com/ipython/ipython/issues/734>`_: Allow %magic argument filenames with spaces to be specified with quotes under win32
 * `731 <https://github.com/ipython/ipython/issues/731>`_: respect encoding of display data from urls
 * `730 <https://github.com/ipython/ipython/issues/730>`_: doc improvements for running notebook via secure protocol
 * `729 <https://github.com/ipython/ipython/issues/729>`_: use null char to start markdown cell placeholder
 * `727 <https://github.com/ipython/ipython/issues/727>`_: Minor fixes to the htmlnotebook
 * `726 <https://github.com/ipython/ipython/issues/726>`_: use bundled argparse if system argparse is < 1.1
 * `705 <https://github.com/ipython/ipython/issues/705>`_: Htmlnotebook
 * `723 <https://github.com/ipython/ipython/issues/723>`_: Add 'import time' to IPython/parallel/apps/launcher.py as time.sleep is called without time being imported
 * `714 <https://github.com/ipython/ipython/issues/714>`_: Install mathjax for offline use
 * `718 <https://github.com/ipython/ipython/issues/718>`_: Underline keyboard shortcut characters on appropriate buttons
 * `717 <https://github.com/ipython/ipython/issues/717>`_: Add source highlighting to markdown snippets
 * `716 <https://github.com/ipython/ipython/issues/716>`_: update EvalFormatter to allow arbitrary expressions
 * `712 <https://github.com/ipython/ipython/issues/712>`_: Reset execution counter after cache is cleared
 * `713 <https://github.com/ipython/ipython/issues/713>`_: Align colons in html notebook help dialog
 * `709 <https://github.com/ipython/ipython/issues/709>`_: Allow usage of '.' in notebook names
 * `706 <https://github.com/ipython/ipython/issues/706>`_: Implement static publishing of HTML notebook
 * `674 <https://github.com/ipython/ipython/issues/674>`_: use argparse to parse aliases & flags
 * `679 <https://github.com/ipython/ipython/issues/679>`_: HistoryManager.get_session_info()
 * `696 <https://github.com/ipython/ipython/issues/696>`_: Fix columnize bug, where tab completion with very long filenames would crash Qt console
 * `686 <https://github.com/ipython/ipython/issues/686>`_: add ssh tunnel support to qtconsole
 * `685 <https://github.com/ipython/ipython/issues/685>`_: Add SSH tunneling to engines
 * `384 <https://github.com/ipython/ipython/issues/384>`_: Allow pickling objects defined interactively.
 * `647 <https://github.com/ipython/ipython/issues/647>`_: My fix rpmlint
 * `587 <https://github.com/ipython/ipython/issues/587>`_: don't special case for py3k+numpy
 * `703 <https://github.com/ipython/ipython/issues/703>`_: make config-loading debug messages more explicit
 * `699 <https://github.com/ipython/ipython/issues/699>`_: make calltips configurable in qtconsole
 * `666 <https://github.com/ipython/ipython/issues/666>`_: parallel tests & extra readline escapes
 * `683 <https://github.com/ipython/ipython/issues/683>`_: BF - allow nose with-doctest setting in environment
 * `689 <https://github.com/ipython/ipython/issues/689>`_: Protect ipkernel from bad messages
 * `702 <https://github.com/ipython/ipython/issues/702>`_: Prevent ipython.py launcher from being imported.
 * `701 <https://github.com/ipython/ipython/issues/701>`_: Prevent ipython.py from being imported by accident
 * `670 <https://github.com/ipython/ipython/issues/670>`_: check for writable dirs, not just existence, in utils.path
 * `579 <https://github.com/ipython/ipython/issues/579>`_: Sessionwork
 * `687 <https://github.com/ipython/ipython/issues/687>`_: add `ipython kernel` for starting just a kernel
 * `627 <https://github.com/ipython/ipython/issues/627>`_: Qt Console history search
 * `646 <https://github.com/ipython/ipython/issues/646>`_: Generate package list automatically in find_packages
 * `660 <https://github.com/ipython/ipython/issues/660>`_: i658
 * `659 <https://github.com/ipython/ipython/issues/659>`_: don't crash on bad config files
 
 Regular issues (258):
 
 * `1177 <https://github.com/ipython/ipython/issues/1177>`_: UnicodeDecodeError in py3compat from "xlrd??"
 * `1094 <https://github.com/ipython/ipython/issues/1094>`_: Tooltip doesn't show constructor docstrings
 * `1170 <https://github.com/ipython/ipython/issues/1170>`_: double pylab greeting with c.InteractiveShellApp.pylab = "tk" in zmqconsole
 * `1166 <https://github.com/ipython/ipython/issues/1166>`_: E-mail cpaste broken
 * `1164 <https://github.com/ipython/ipython/issues/1164>`_: IPython qtconsole (0.12) can't export to html with external png
 * `1103 <https://github.com/ipython/ipython/issues/1103>`_: %loadpy should cut out encoding declaration
 * `1156 <https://github.com/ipython/ipython/issues/1156>`_: Notebooks downloaded as Python files require a header stating the encoding
 * `1157 <https://github.com/ipython/ipython/issues/1157>`_: Ctrl-C not working when GUI/pylab integration is active
 * `1154 <https://github.com/ipython/ipython/issues/1154>`_: We should be less aggressive in de-registering post-execution functions
 * `1134 <https://github.com/ipython/ipython/issues/1134>`_: "select-all, kill" leaves qtconsole in unusable state
 * `1148 <https://github.com/ipython/ipython/issues/1148>`_: A lot of testerrors
 * `803 <https://github.com/ipython/ipython/issues/803>`_: Make doctests work with Python 3
 * `1119 <https://github.com/ipython/ipython/issues/1119>`_: Start menu shortcuts not created in Python 3
 * `1136 <https://github.com/ipython/ipython/issues/1136>`_: The embedding machinery ignores user_ns
 * `607 <https://github.com/ipython/ipython/issues/607>`_: Use the new IPython logo/font in the notebook header
 * `755 <https://github.com/ipython/ipython/issues/755>`_: qtconsole ipython widget's execute_file fails if filename contains spaces or quotes
 * `1115 <https://github.com/ipython/ipython/issues/1115>`_: shlex_split should return unicode
 * `1109 <https://github.com/ipython/ipython/issues/1109>`_: timeit with string ending in space gives "ValueError: No closing quotation"
 * `1142 <https://github.com/ipython/ipython/issues/1142>`_: Install problems
 * `700 <https://github.com/ipython/ipython/issues/700>`_: Some SVG images render incorrectly in htmlnotebook
 * `1117 <https://github.com/ipython/ipython/issues/1117>`_: quit() doesn't work in terminal
 * `1111 <https://github.com/ipython/ipython/issues/1111>`_: ls broken after merge of #1089
 * `1104 <https://github.com/ipython/ipython/issues/1104>`_: Prompt spacing weird
 * `1124 <https://github.com/ipython/ipython/issues/1124>`_: Seg Fault 11 when calling PySide using "run" command
 * `1088 <https://github.com/ipython/ipython/issues/1088>`_: QtConsole : can't copy from pager
 * `568 <https://github.com/ipython/ipython/issues/568>`_: Test error and failure in IPython.core on windows
 * `1112 <https://github.com/ipython/ipython/issues/1112>`_: testfailure in IPython.frontend on windows
 * `1102 <https://github.com/ipython/ipython/issues/1102>`_: magic in IPythonDemo fails when not located at top of demo file
 * `629 <https://github.com/ipython/ipython/issues/629>`_: \r and \b in qtconsole don't behave as expected
 * `1080 <https://github.com/ipython/ipython/issues/1080>`_: Notebook: tab completion should close on "("
 * `973 <https://github.com/ipython/ipython/issues/973>`_: Qt Console close dialog and on-top Qt Console
 * `1087 <https://github.com/ipython/ipython/issues/1087>`_: QtConsole xhtml/Svg export broken ?
 * `1067 <https://github.com/ipython/ipython/issues/1067>`_: Parallel test suite hangs on Python 3
 * `1018 <https://github.com/ipython/ipython/issues/1018>`_: Local mathjax breaks install
 * `993 <https://github.com/ipython/ipython/issues/993>`_: `raw_input` redirection to foreign kernels is extremely brittle
 * `1100 <https://github.com/ipython/ipython/issues/1100>`_: ipython3 traceback unicode issue from extensions
 * `1071 <https://github.com/ipython/ipython/issues/1071>`_: Large html-notebooks hang on load on a slow machine
 * `89 <https://github.com/ipython/ipython/issues/89>`_: %pdoc np.ma.compress shows docstring twice
 * `22 <https://github.com/ipython/ipython/issues/22>`_: Include improvements from anythingipython.el
 * `633 <https://github.com/ipython/ipython/issues/633>`_: Execution count & SyntaxError
 * `1095 <https://github.com/ipython/ipython/issues/1095>`_: Uncaught TypeError: Object has no method 'remove_and_cancell_tooltip'
 * `1075 <https://github.com/ipython/ipython/issues/1075>`_: We're ignoring prompt customizations
 * `1086 <https://github.com/ipython/ipython/issues/1086>`_: Can't open qtconsole from outside source tree
 * `1076 <https://github.com/ipython/ipython/issues/1076>`_: namespace changes broke `foo.*bar*?` syntax
 * `1074 <https://github.com/ipython/ipython/issues/1074>`_: pprinting old-style class objects fails (TypeError: 'tuple' object is not callable)
 * `1063 <https://github.com/ipython/ipython/issues/1063>`_: IPython.utils test error due to missing unicodedata module
 * `592 <https://github.com/ipython/ipython/issues/592>`_: Bug in argument parsing for %run
 * `378 <https://github.com/ipython/ipython/issues/378>`_: Windows path escape issues
 * `1068 <https://github.com/ipython/ipython/issues/1068>`_: Notebook tab completion broken in Firefox
 * `75 <https://github.com/ipython/ipython/issues/75>`_: No tab completion after "/
 * `103 <https://github.com/ipython/ipython/issues/103>`_: customizable cpaste
 * `324 <https://github.com/ipython/ipython/issues/324>`_: Remove code in IPython.testing that is not being used
 * `131 <https://github.com/ipython/ipython/issues/131>`_: Global variables not seen by cprofile.run()
 * `851 <https://github.com/ipython/ipython/issues/851>`_: IPython shell swallows exceptions in certain circumstances
 * `882 <https://github.com/ipython/ipython/issues/882>`_: ipython freezes at start if IPYTHONDIR is on an NFS mount
 * `1057 <https://github.com/ipython/ipython/issues/1057>`_: Blocker: Qt console broken after "all magics" menu became dynamic
 * `1027 <https://github.com/ipython/ipython/issues/1027>`_: ipython does not like white space at end of file
 * `1058 <https://github.com/ipython/ipython/issues/1058>`_: New bug: Notebook asks for confirmation to leave even saved pages.
 * `1061 <https://github.com/ipython/ipython/issues/1061>`_: rep (magic recall) under pypy
 * `1047 <https://github.com/ipython/ipython/issues/1047>`_: Document the notebook format
 * `102 <https://github.com/ipython/ipython/issues/102>`_: Properties accessed twice for classes defined interactively
 * `16 <https://github.com/ipython/ipython/issues/16>`_: %store raises exception when storing compiled regex
 * `67 <https://github.com/ipython/ipython/issues/67>`_: tab expansion should only take one directory level at the time
 * `62 <https://github.com/ipython/ipython/issues/62>`_: Global variables undefined in interactive use of embedded ipython shell
 * `57 <https://github.com/ipython/ipython/issues/57>`_: debugging with ipython does not work well outside ipython
 * `38 <https://github.com/ipython/ipython/issues/38>`_: Line entry edge case error
 * `980 <https://github.com/ipython/ipython/issues/980>`_: Update parallel docs for new parallel architecture
 * `1017 <https://github.com/ipython/ipython/issues/1017>`_: Add small example about ipcluster/ssh startup
 * `1041 <https://github.com/ipython/ipython/issues/1041>`_: Proxy Issues
 * `967 <https://github.com/ipython/ipython/issues/967>`_: KernelManagers don't use zmq eventloop properly
 * `1055 <https://github.com/ipython/ipython/issues/1055>`_: "All Magics" display on Ubuntu 
 * `1054 <https://github.com/ipython/ipython/issues/1054>`_: ipython explodes on syntax error
 * `1051 <https://github.com/ipython/ipython/issues/1051>`_: ipython3 set_next_input() failure
 * `693 <https://github.com/ipython/ipython/issues/693>`_: "run -i" no longer works after %reset in terminal
 * `29 <https://github.com/ipython/ipython/issues/29>`_: cPickle works in standard interpreter, but not in IPython
 * `1050 <https://github.com/ipython/ipython/issues/1050>`_: ipython3 broken by commit 8bb887c8c2c447bf7
 * `1048 <https://github.com/ipython/ipython/issues/1048>`_: Update docs on notebook password
 * `1046 <https://github.com/ipython/ipython/issues/1046>`_: Searies of questions/issues?
 * `1045 <https://github.com/ipython/ipython/issues/1045>`_: crash when exiting - previously launched embedded sub-shell
 * `1043 <https://github.com/ipython/ipython/issues/1043>`_: pylab doesn't work in qtconsole
 * `1044 <https://github.com/ipython/ipython/issues/1044>`_: run -p doesn't work in python 3
 * `1010 <https://github.com/ipython/ipython/issues/1010>`_: emacs freezes when ipython-complete is called
 * `82 <https://github.com/ipython/ipython/issues/82>`_: Update devel docs with discussion about good changelogs
 * `116 <https://github.com/ipython/ipython/issues/116>`_: Update release management scipts and release.revision for git
 * `1022 <https://github.com/ipython/ipython/issues/1022>`_: Pylab banner shows up with first cell to execute
 * `787 <https://github.com/ipython/ipython/issues/787>`_: Keyboard selection of multiple lines in the notebook behaves inconsistently
 * `1037 <https://github.com/ipython/ipython/issues/1037>`_: notepad + jsonlib: TypeError: Only whitespace may be used for indentation.
 * `970 <https://github.com/ipython/ipython/issues/970>`_: Default home not writable, %HOME% does not help (windows)
 * `747 <https://github.com/ipython/ipython/issues/747>`_: HOMESHARE not a good choice for "writable homedir" on Windows
 * `810 <https://github.com/ipython/ipython/issues/810>`_: cleanup utils.path.get_home_dir
 * `2 <https://github.com/ipython/ipython/issues/2>`_: Fix the copyright statement in source code files to be accurate
 * `1031 <https://github.com/ipython/ipython/issues/1031>`_: <esc> on Firefox crash websocket
 * `684 <https://github.com/ipython/ipython/issues/684>`_: %Store eliminated in configuration and magic commands in 0.11
 * `1026 <https://github.com/ipython/ipython/issues/1026>`_: BUG: wrong default parameter in ask_yes_no
 * `880 <https://github.com/ipython/ipython/issues/880>`_: Better error message if %paste fails
 * `1024 <https://github.com/ipython/ipython/issues/1024>`_: autopx magic broken 
 * `822 <https://github.com/ipython/ipython/issues/822>`_: Unicode bug in Itpl when expanding shell variables in syscalls with !
 * `1009 <https://github.com/ipython/ipython/issues/1009>`_: Windows: regression in cd magic handling of paths
 * `833 <https://github.com/ipython/ipython/issues/833>`_: Crash python with matplotlib and unequal length arrays
 * `695 <https://github.com/ipython/ipython/issues/695>`_: Crash handler initialization is too aggressive
 * `1000 <https://github.com/ipython/ipython/issues/1000>`_: Remove duplicates when refilling readline history
 * `992 <https://github.com/ipython/ipython/issues/992>`_: Interrupting certain matplotlib operations leaves the inline backend 'wedged'
 * `942 <https://github.com/ipython/ipython/issues/942>`_: number traits should cast if value doesn't change
 * `1006 <https://github.com/ipython/ipython/issues/1006>`_: ls crashes when run on a UNC path or with non-ascii args
 * `944 <https://github.com/ipython/ipython/issues/944>`_: Decide the default image format for inline figures: SVG or PNG?
 * `842 <https://github.com/ipython/ipython/issues/842>`_: Python 3 on Windows (pyreadline) - expected an object with the buffer interface
 * `1002 <https://github.com/ipython/ipython/issues/1002>`_: ImportError due to incorrect version checking
 * `1001 <https://github.com/ipython/ipython/issues/1001>`_: Ipython "source" command?
 * `954 <https://github.com/ipython/ipython/issues/954>`_: IPython embed doesn't respect namespaces
 * `681 <https://github.com/ipython/ipython/issues/681>`_: pdb freezes inside qtconsole
 * `698 <https://github.com/ipython/ipython/issues/698>`_: crash report "TypeError: can only concatenate list (not "unicode") to list"
 * `978 <https://github.com/ipython/ipython/issues/978>`_: ipython 0.11 buffers external command output till the cmd is done
 * `952 <https://github.com/ipython/ipython/issues/952>`_: Need user-facing warning in the browser if websocket connection fails
 * `988 <https://github.com/ipython/ipython/issues/988>`_: Error using idlsave
 * `990 <https://github.com/ipython/ipython/issues/990>`_: ipython notebook - kernel dies if matplotlib is not installed
 * `752 <https://github.com/ipython/ipython/issues/752>`_: Matplotlib figures showed only once in notebook
 * `54 <https://github.com/ipython/ipython/issues/54>`_: Exception hook should be optional for embedding IPython in GUIs
 * `918 <https://github.com/ipython/ipython/issues/918>`_: IPython.frontend tests fail without tornado
 * `986 <https://github.com/ipython/ipython/issues/986>`_: Views created with c.direct_view() fail
 * `697 <https://github.com/ipython/ipython/issues/697>`_: Filter out from %who names loaded at initialization time
 * `932 <https://github.com/ipython/ipython/issues/932>`_: IPython 0.11 quickref card has superfluous "%recall and"
 * `982 <https://github.com/ipython/ipython/issues/982>`_: png files with executable permissions
 * `914 <https://github.com/ipython/ipython/issues/914>`_: Simpler system for running code after InteractiveShell is initialised
 * `911 <https://github.com/ipython/ipython/issues/911>`_: ipython crashes on startup if readline is missing
 * `971 <https://github.com/ipython/ipython/issues/971>`_: bookmarks created in 0.11 are corrupt in 0.12
 * `974 <https://github.com/ipython/ipython/issues/974>`_: object feature tab-completion crash
 * `939 <https://github.com/ipython/ipython/issues/939>`_: ZMQShell always uses default profile
 * `946 <https://github.com/ipython/ipython/issues/946>`_: Multi-tab Close action should offer option to leave all kernels alone
 * `949 <https://github.com/ipython/ipython/issues/949>`_: Test suite must not require any manual interaction
 * `643 <https://github.com/ipython/ipython/issues/643>`_: enable gui eventloop integration in ipkernel
 * `965 <https://github.com/ipython/ipython/issues/965>`_: ipython is crashed without launch.(python3.2)
 * `958 <https://github.com/ipython/ipython/issues/958>`_: Can't use os X clipboard on with qtconsole
 * `962 <https://github.com/ipython/ipython/issues/962>`_: Don't require tornado in the tests
 * `960 <https://github.com/ipython/ipython/issues/960>`_: crash on syntax error on Windows XP
 * `934 <https://github.com/ipython/ipython/issues/934>`_: The latest ipython branch doesn't work in Chrome
 * `870 <https://github.com/ipython/ipython/issues/870>`_: zmq version detection
 * `943 <https://github.com/ipython/ipython/issues/943>`_: HISTIGNORE for IPython
 * `947 <https://github.com/ipython/ipython/issues/947>`_: qtconsole segfaults at startup
 * `903 <https://github.com/ipython/ipython/issues/903>`_: Expose a magic to control config of the inline pylab backend
 * `908 <https://github.com/ipython/ipython/issues/908>`_: bad user config shouldn't crash IPython
 * `935 <https://github.com/ipython/ipython/issues/935>`_: Typing `break` causes IPython to crash.
 * `869 <https://github.com/ipython/ipython/issues/869>`_: Tab completion of `~/` shows no output post 0.10.x
 * `904 <https://github.com/ipython/ipython/issues/904>`_: whos under pypy1.6
 * `773 <https://github.com/ipython/ipython/issues/773>`_: check_security_dir() and check_pid_dir() fail on network filesystem
 * `915 <https://github.com/ipython/ipython/issues/915>`_: OS X Lion Terminal.app line wrap problem
 * `886 <https://github.com/ipython/ipython/issues/886>`_: Notebook kernel crash when specifying --notebook-dir on commandline
 * `636 <https://github.com/ipython/ipython/issues/636>`_: debugger.py: pydb broken
 * `808 <https://github.com/ipython/ipython/issues/808>`_: Ctrl+C during %reset confirm message crash Qtconsole
 * `927 <https://github.com/ipython/ipython/issues/927>`_: Using return outside a function crashes ipython
 * `919 <https://github.com/ipython/ipython/issues/919>`_: Pop-up segfault when moving cursor out of qtconsole window
 * `181 <https://github.com/ipython/ipython/issues/181>`_: cls command does not work on windows
 * `917 <https://github.com/ipython/ipython/issues/917>`_: documentation typos
 * `818 <https://github.com/ipython/ipython/issues/818>`_: %run does not work with non-ascii characeters in path
 * `907 <https://github.com/ipython/ipython/issues/907>`_: Errors in custom completer functions can crash IPython
 * `867 <https://github.com/ipython/ipython/issues/867>`_: doc: notebook password authentication howto
 * `211 <https://github.com/ipython/ipython/issues/211>`_: paste command not working
 * `900 <https://github.com/ipython/ipython/issues/900>`_: Tab key should insert 4 spaces in qt console
 * `513 <https://github.com/ipython/ipython/issues/513>`_: [Qt console] cannot insert new lines into console functions using tab
 * `906 <https://github.com/ipython/ipython/issues/906>`_: qtconsoleapp 'parse_command_line' doen't like --existing anymore
 * `638 <https://github.com/ipython/ipython/issues/638>`_: Qt console --pylab=inline and getfigs(), etc.
 * `710 <https://github.com/ipython/ipython/issues/710>`_: unwanted unicode passed to args
 * `436 <https://github.com/ipython/ipython/issues/436>`_: Users should see tooltips for all buttons in the notebook UI
 * `207 <https://github.com/ipython/ipython/issues/207>`_: ipython crashes if atexit handler raises exception
 * `692 <https://github.com/ipython/ipython/issues/692>`_: use of Tracer() when debugging works but gives error messages
 * `690 <https://github.com/ipython/ipython/issues/690>`_: debugger does not print error message by default in 0.11
 * `571 <https://github.com/ipython/ipython/issues/571>`_: history of multiline entries
 * `749 <https://github.com/ipython/ipython/issues/749>`_: IPython.parallel test failure under Windows 7 and XP
 * `890 <https://github.com/ipython/ipython/issues/890>`_: ipclusterapp.py - helep
 * `885 <https://github.com/ipython/ipython/issues/885>`_: `ws-hostname` alias not recognized by notebook
 * `881 <https://github.com/ipython/ipython/issues/881>`_: Missing manual.pdf?
 * `744 <https://github.com/ipython/ipython/issues/744>`_: cannot create notebook in offline mode if mathjax not installed
 * `865 <https://github.com/ipython/ipython/issues/865>`_: Make tracebacks from %paste show the code
 * `535 <https://github.com/ipython/ipython/issues/535>`_: exception unicode handling in %run is faulty in qtconsole
 * `817 <https://github.com/ipython/ipython/issues/817>`_: iPython crashed
 * `799 <https://github.com/ipython/ipython/issues/799>`_: %edit magic not working on windows xp in qtconsole
 * `732 <https://github.com/ipython/ipython/issues/732>`_: QTConsole wrongly promotes the index of the input line on which user presses Enter
 * `662 <https://github.com/ipython/ipython/issues/662>`_: ipython test failures on Mac OS X Lion
 * `650 <https://github.com/ipython/ipython/issues/650>`_: Handle bad config files better
 * `829 <https://github.com/ipython/ipython/issues/829>`_: We should not insert new lines after all print statements in the notebook
 * `874 <https://github.com/ipython/ipython/issues/874>`_: ipython-qtconsole: pyzmq Version Comparison
 * `640 <https://github.com/ipython/ipython/issues/640>`_: matplotlib macosx windows don't respond in qtconsole
 * `624 <https://github.com/ipython/ipython/issues/624>`_: ipython intermittently segfaults when figure is closed (Mac OS X)
 * `871 <https://github.com/ipython/ipython/issues/871>`_: Notebook crashes if a profile is used
 * `56 <https://github.com/ipython/ipython/issues/56>`_: Have %cpaste accept also Ctrl-D as a termination marker
 * `849 <https://github.com/ipython/ipython/issues/849>`_: Command line options to not override profile options
 * `806 <https://github.com/ipython/ipython/issues/806>`_: Provide single-port connection to kernels
 * `691 <https://github.com/ipython/ipython/issues/691>`_: [wishlist] Automatically find existing kernel
 * `688 <https://github.com/ipython/ipython/issues/688>`_: local security vulnerability: all ports visible to any local user.
 * `866 <https://github.com/ipython/ipython/issues/866>`_: DistributionNotFound on running ipython 0.11 on Windows XP x86
 * `673 <https://github.com/ipython/ipython/issues/673>`_: raw_input appears to be round-robin for qtconsole
 * `863 <https://github.com/ipython/ipython/issues/863>`_: Graceful degradation when home directory not writable
 * `800 <https://github.com/ipython/ipython/issues/800>`_: Timing scripts with run -t -N <N> fails on report output
 * `858 <https://github.com/ipython/ipython/issues/858>`_: Typing 'continue' makes ipython0.11 crash
 * `840 <https://github.com/ipython/ipython/issues/840>`_: all processes run on one CPU core
 * `843 <https://github.com/ipython/ipython/issues/843>`_: "import braces" crashes ipython
 * `836 <https://github.com/ipython/ipython/issues/836>`_: Strange Output after IPython Install
 * `839 <https://github.com/ipython/ipython/issues/839>`_: Qtconsole segfaults when mouse exits window with active tooltip
 * `827 <https://github.com/ipython/ipython/issues/827>`_: Add support for checking several limits before running task on engine
 * `826 <https://github.com/ipython/ipython/issues/826>`_: Add support for creation of parallel task when no engine is running
 * `832 <https://github.com/ipython/ipython/issues/832>`_: Improve error message for %logstop
 * `831 <https://github.com/ipython/ipython/issues/831>`_: %logstart in read-only directory forbid any further command
 * `814 <https://github.com/ipython/ipython/issues/814>`_: ipython does not start -- DistributionNotFound
 * `794 <https://github.com/ipython/ipython/issues/794>`_: Allow >1 controller per profile
 * `820 <https://github.com/ipython/ipython/issues/820>`_: Tab Completion feature
 * `812 <https://github.com/ipython/ipython/issues/812>`_: Qt console crashes on Ubuntu 11.10
 * `816 <https://github.com/ipython/ipython/issues/816>`_: Import error using Python 2.7 and dateutil2.0 No module named _thread
 * `756 <https://github.com/ipython/ipython/issues/756>`_: qtconsole Windows fails to print error message for '%run nonexistent_file'
 * `651 <https://github.com/ipython/ipython/issues/651>`_: Completion doesn't work on element of a list
 * `617 <https://github.com/ipython/ipython/issues/617>`_: [qtconsole] %hist doesn't show anything in qtconsole
 * `786 <https://github.com/ipython/ipython/issues/786>`_: from __future__ import unicode_literals does not work
 * `779 <https://github.com/ipython/ipython/issues/779>`_: Using irunner from virtual evn uses systemwide ipython
 * `768 <https://github.com/ipython/ipython/issues/768>`_: codepage handling of output from scripts and shellcommands are not handled properly by qtconsole
 * `785 <https://github.com/ipython/ipython/issues/785>`_: Don't strip leading whitespace in repr() in notebook
 * `737 <https://github.com/ipython/ipython/issues/737>`_: in pickleshare.py line52 should be "if not os.path.isdir(self.root):"?
 * `738 <https://github.com/ipython/ipython/issues/738>`_: in ipthon_win_post_install.py line 38
 * `777 <https://github.com/ipython/ipython/issues/777>`_: print(…, sep=…) raises SyntaxError
 * `728 <https://github.com/ipython/ipython/issues/728>`_: ipcontroller crash with MPI
 * `780 <https://github.com/ipython/ipython/issues/780>`_: qtconsole Out value prints before the print statements that precede it
 * `632 <https://github.com/ipython/ipython/issues/632>`_: IPython Crash Report (0.10.2)
 * `253 <https://github.com/ipython/ipython/issues/253>`_: Unable to install ipython on windows
 * `80 <https://github.com/ipython/ipython/issues/80>`_: Split IPClusterApp into multiple Application subclasses for each subcommand
 * `34 <https://github.com/ipython/ipython/issues/34>`_: non-blocking pendingResult partial results
 * `739 <https://github.com/ipython/ipython/issues/739>`_: Tests fail if tornado not installed
 * `719 <https://github.com/ipython/ipython/issues/719>`_: Better support Pypy
 * `667 <https://github.com/ipython/ipython/issues/667>`_: qtconsole problem with default pylab profile
 * `661 <https://github.com/ipython/ipython/issues/661>`_: ipythonrc referenced in magic command in 0.11
 * `665 <https://github.com/ipython/ipython/issues/665>`_: Source introspection with ?? is broken
 * `724 <https://github.com/ipython/ipython/issues/724>`_: crash - ipython qtconsole, %quickref
 * `655 <https://github.com/ipython/ipython/issues/655>`_: ipython with qtconsole crashes
 * `593 <https://github.com/ipython/ipython/issues/593>`_: HTML Notebook Prompt can be deleted . . .
 * `563 <https://github.com/ipython/ipython/issues/563>`_: use argparse instead of kvloader for flags&aliases
 * `751 <https://github.com/ipython/ipython/issues/751>`_: Tornado version greater than 2.0 needed for firefox 6
 * `720 <https://github.com/ipython/ipython/issues/720>`_: Crash report when importing easter egg
 * `740 <https://github.com/ipython/ipython/issues/740>`_: Ctrl-Enter clears line in notebook
 * `772 <https://github.com/ipython/ipython/issues/772>`_: ipengine fails on Windows with "XXX lineno: 355, opcode: 0"
 * `771 <https://github.com/ipython/ipython/issues/771>`_: Add python 3 tag to setup.py
 * `767 <https://github.com/ipython/ipython/issues/767>`_: non-ascii in __doc__ string crashes qtconsole kernel when showing tooltip
 * `733 <https://github.com/ipython/ipython/issues/733>`_: In Windows, %run fails to strip quotes from filename
 * `721 <https://github.com/ipython/ipython/issues/721>`_: no completion in emacs by ipython(ipython.el)
 * `669 <https://github.com/ipython/ipython/issues/669>`_: Do not accept an ipython_dir that's not writeable
 * `711 <https://github.com/ipython/ipython/issues/711>`_: segfault on mac os x
 * `500 <https://github.com/ipython/ipython/issues/500>`_: "RuntimeError: Cannot change input buffer during execution" in console_widget.py
 * `707 <https://github.com/ipython/ipython/issues/707>`_: Copy and paste keyboard shortcuts do not work in Qt Console on OS X
 * `478 <https://github.com/ipython/ipython/issues/478>`_: PyZMQ's use of memoryviews breaks reconstruction of numpy arrays
 * `694 <https://github.com/ipython/ipython/issues/694>`_: Turning off callout tips in qtconsole
 * `704 <https://github.com/ipython/ipython/issues/704>`_: return kills IPython
 * `442 <https://github.com/ipython/ipython/issues/442>`_: Users should have intelligent autoindenting in the notebook
 * `615 <https://github.com/ipython/ipython/issues/615>`_: Wireframe and implement a project dashboard page
 * `614 <https://github.com/ipython/ipython/issues/614>`_: Wireframe and implement a notebook dashboard page
 * `606 <https://github.com/ipython/ipython/issues/606>`_: Users should be able to use the notebook to import/export a notebook to .py or .rst
 * `604 <https://github.com/ipython/ipython/issues/604>`_: A user should be able to leave a kernel running in the notebook and reconnect
 * `298 <https://github.com/ipython/ipython/issues/298>`_: Users should be able to save a notebook and then later reload it
 * `649 <https://github.com/ipython/ipython/issues/649>`_: ipython qtconsole (v0.11): setting "c.IPythonWidget.in_prompt = '>>> ' crashes
 * `672 <https://github.com/ipython/ipython/issues/672>`_: What happened to Exit?
 * `658 <https://github.com/ipython/ipython/issues/658>`_: Put the InteractiveShellApp section first in the auto-generated config files
 * `656 <https://github.com/ipython/ipython/issues/656>`_: [suggestion] dependency checking for pyqt for  Windows installer
 * `654 <https://github.com/ipython/ipython/issues/654>`_: broken documentation link on download page
 * `653 <https://github.com/ipython/ipython/issues/653>`_: Test failures in IPython.parallel

docs/source/whatsnew/github-stats-1.0.rst

@@ -1,1784 +1,1784 b''
 .. _issues_list_100:
 
 Issues closed in the 1.0 development cycle
 ==========================================
 
 Issues closed in 1.1
 --------------------
 
 GitHub stats for 2013/08/08 - 2013/09/09 (since 1.0)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 25 authors contributed 337 commits.
 
 * Benjamin Ragan-Kelley
 * Bing Xia
 * Bradley M. Froehle
 * Brian E. Granger
 * Damián Avila
 * dhirschfeld
 * Dražen Lučanin
 * gmbecker
 * Jake Vanderplas
 * Jason Grout
 * Jonathan Frederic
 * Kevin Burke
 * Kyle Kelley
 * Matt Henderson
 * Matthew Brett
 * Matthias Bussonnier
 * Pankaj Pandey
 * Paul Ivanov
 * rossant
 * Samuel Ainsworth
 * Stephan Rave
 * stonebig
 * Thomas Kluyver
 * Yaroslav Halchenko
 * Zachary Sailer
 
 
 We closed a total of 76 issues, 58 pull requests and 18 regular issues;
 this is the full list (generated with the script :file:`tools/github_stats.py`):
 
 Pull Requests (58):
 
 * :ghpull:`4188`: Allow user_ns trait to be None
 * :ghpull:`4189`: always fire LOCAL_IPS.extend(PUBLIC_IPS)
 * :ghpull:`4174`: various issues in markdown and rst templates
 * :ghpull:`4178`: add missing data_javascript
 * :ghpull:`4181`: nbconvert: Fix, sphinx template not removing new lines from headers
 * :ghpull:`4043`: don't 'restore_bytes' in from_JSON
 * :ghpull:`4163`: Fix for incorrect default encoding on Windows.
 * :ghpull:`4136`: catch javascript errors in any output
 * :ghpull:`4171`: add nbconvert config file when creating profiles
 * :ghpull:`4125`: Basic exercise of `ipython [subcommand] -h` and help-all
 * :ghpull:`4085`: nbconvert: Fix sphinx preprocessor date format string for Windows
 * :ghpull:`4159`: don't split `.cell` and `div.cell` CSS
 * :ghpull:`4158`: generate choices for `--gui` configurable from real mapping
 * :ghpull:`4065`: do not include specific css in embedable one
 * :ghpull:`4092`: nbconvert: Fix for unicode html headers, Windows + Python 2.x
 * :ghpull:`4074`: close Client sockets if connection fails
 * :ghpull:`4064`: Store default codemirror mode in only 1 place
 * :ghpull:`4104`: Add way to install MathJax to a particular profile
 * :ghpull:`4144`: help_end transformer shouldn't pick up ? in multiline string
 * :ghpull:`4143`: update example custom.js
 * :ghpull:`4142`: DOC: unwrap openssl line in public_server doc
 * :ghpull:`4141`: add files with a separate `add` call in backport_pr
 * :ghpull:`4137`: Restore autorestore option for storemagic
 * :ghpull:`4098`: pass profile-dir instead of profile name to Kernel
 * :ghpull:`4120`: support `input` in Python 2 kernels
 * :ghpull:`4088`: nbconvert: Fix coalescestreams line with incorrect nesting causing strange behavior
 * :ghpull:`4060`: only strip continuation prompts if regular prompts seen first
 * :ghpull:`4132`: Fixed name error bug in function safe_unicode in module py3compat.
 * :ghpull:`4121`: move test_kernel from IPython.zmq to IPython.kernel
 * :ghpull:`4118`: ZMQ heartbeat channel: catch EINTR exceptions and continue.
 * :ghpull:`4054`: use unicode for HTML export
 * :ghpull:`4106`: fix a couple of default block values
 * :ghpull:`4115`: Update docs on declaring a magic function
 * :ghpull:`4101`: restore accidentally removed EngineError
 * :ghpull:`4096`: minor docs changes
 * :ghpull:`4056`: respect `pylab_import_all` when `--pylab` specified at the command-line
 * :ghpull:`4091`: Make Qt console banner configurable
 * :ghpull:`4086`: fix missing errno import
 * :ghpull:`4030`: exclude `.git` in MANIFEST.in
 * :ghpull:`4047`: Use istype() when checking if canned object is a dict
 * :ghpull:`4031`: don't close_fds on Windows
 * :ghpull:`4029`: bson.Binary moved
 * :ghpull:`4035`: Fixed custom jinja2 templates being ignored when setting template_path
 * :ghpull:`4026`: small doc fix in nbconvert
 * :ghpull:`4016`: Fix IPython.start_* functions
 * :ghpull:`4021`: Fix parallel.client.View map() on numpy arrays
 * :ghpull:`4022`: DOC: fix links to matplotlib, notebook docs
 * :ghpull:`4018`: Fix warning when running IPython.kernel tests
 * :ghpull:`4019`: Test skipping without unicode paths
 * :ghpull:`4008`: Transform code before %prun/%%prun runs
 * :ghpull:`4014`: Fix typo in ipapp
 * :ghpull:`3987`: get files list in backport_pr
 * :ghpull:`3974`: nbconvert: Fix app tests on Window7 w/ Python 3.3
 * :ghpull:`3978`: fix `--existing` with non-localhost IP
 * :ghpull:`3939`: minor checkpoint cleanup
 * :ghpull:`3981`: BF: fix nbconvert rst input prompt spacing
 * :ghpull:`3960`: Don't make sphinx a dependency for importing nbconvert
 * :ghpull:`3973`: logging.Formatter is not new-style in 2.6
 
 Issues (18):
 
 * :ghissue:`4024`: nbconvert markdown issues
 * :ghissue:`4095`: Catch js error in append html in stream/pyerr
 * :ghissue:`4156`: Specifying --gui=tk at the command line
 * :ghissue:`3818`: nbconvert can't handle Heading with Chinese characters on Japanese Windows OS.
 * :ghissue:`4134`: multi-line parser fails on ''' in comment, qtconsole and notebook.
 * :ghissue:`3998`: sample custom.js needs to be updated
 * :ghissue:`4078`: StoreMagic.autorestore not working in 1.0.0
 * :ghissue:`3990`: Buitlin `input` doesn't work over zmq
 * :ghissue:`4015`: nbconvert fails to convert all the content of a notebook
 * :ghissue:`4059`: Issues with Ellipsis literal in Python 3
 * :ghissue:`4103`: Wrong default argument of DirectView.clear
 * :ghissue:`4100`: parallel.client.client references undefined error.EngineError
 * :ghissue:`4005`: IPython.start_kernel doesn't work.
 * :ghissue:`4020`: IPython parallel map fails on numpy arrays
 * :ghissue:`3945`: nbconvert: commandline tests fail Win7x64 Py3.3
 * :ghissue:`3977`: unable to complete remote connections for two-process 
 * :ghissue:`3980`: nbconvert rst output lacks needed blank lines
 * :ghissue:`3968`: TypeError: super() argument 1 must be type, not classobj (Python 2.6.6)
 
 Issues closed in 1.0
 --------------------
 
 GitHub stats for 2012/06/30 - 2013/08/08 (since 0.13)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 155 authors contributed 4258 commits.
 
 * Aaron Meurer
 * Adam Davis
 * Ahmet Bakan
 * Alberto Valverde
 * Allen Riddell
 * Anders Hovmöller
 * Andrea Bedini
 * Andrew Spiers
 * Andrew Vandever
 * Anthony Scopatz
 * Anton Akhmerov
 * Anton I. Sipos
 * Antony Lee
 * Aron Ahmadia
 * Benedikt Sauer
 * Benjamin Jones
 * Benjamin Ragan-Kelley
 * Benjie Chen
 * Boris de Laage
 * Brad Reisfeld
 * Bradley M. Froehle
 * Brian E. Granger
 * Cameron Bates
 * Cavendish McKay
 * chapmanb
 * Chris Beaumont
 * Chris Laumann
 * Christoph Gohlke
 * codebraker
 * codespaced
 * Corran Webster
 * DamianHeard
 * Damián Avila
 * Dan Kilman
 * Dan McDougall
 * Danny Staple
 * David Hirschfeld
 * David P. Sanders
 * David Warde-Farley
 * David Wolever
 * David Wyde
 * debjan
 * Diane Trout
 * dkua
 * Dominik Dabrowski
 * Donald Curtis
 * Dražen Lučanin
 * drevicko
 * Eric O. LEBIGOT
 * Erik M. Bray
 * Erik Tollerud
 * Eugene Van den Bulke
 * Evan Patterson
 * Fernando Perez
 * Francesco Montesano
 * Frank Murphy
 * Greg Caporaso
 * Guy Haskin Fernald
 * guziy
 * Hans Meine
 * Harry Moreno
 * henryiii
 * Ivan Djokic
 * Jack Feser
 * Jake Vanderplas
 * jakobgager
 * James Booth
 * Jan Schulz
 * Jason Grout
 * Jeff Knisley
 * Jens Hedegaard Nielsen
 * jeremiahbuddha
 * Jerry Fowler
 * Jessica B. Hamrick
 * Jez Ng
 * John Zwinck
 * Jonathan Frederic
 * Jonathan Taylor
 * Joon Ro
 * Joseph Lansdowne
 * Juergen Hasch
 * Julian Taylor
 * Jussi Sainio
 * Jörgen Stenarson
 * kevin
 * klonuo
 * Konrad Hinsen
 * Kyle Kelley
 * Lars Solberg
 * Lessandro Mariano
 * Mark Sienkiewicz at STScI
 * Martijn Vermaat
 * Martin Spacek
 * Matthias Bussonnier
 * Maxim Grechkin
 * Maximilian Albert
 * MercuryRising
 * Michael Droettboom
 * Michael Shuffett
 * Michał Górny
 * Mikhail Korobov
 * mr.Shu
 * Nathan Goldbaum
 * ocefpaf
 * Ohad Ravid
 * Olivier Grisel
 * Olivier Verdier
 * Owen Healy
 * Pankaj Pandey
 * Paul Ivanov
 * Pawel Jasinski
 * Pietro Berkes
 * Piti Ongmongkolkul
 * Puneeth Chaganti
 * Rich Wareham
 * Richard Everson
 * Rick Lupton
 * Rob Young
 * Robert Kern
 * Robert Marchman
 * Robert McGibbon
 * Rui Pereira
 * Rustam Safin
 * Ryan May
 * s8weber
 * Samuel Ainsworth
 * Sean Vig
 * Siyu Zhang
 * Skylar Saveland
 * slojo404
 * smithj1
 * Stefan Karpinski
 * Stefan van der Walt
 * Steven Silvester
 * Takafumi Arakaki
 * Takeshi Kanmae
 * tcmulcahy
 * teegaar
 * Thomas Kluyver
 * Thomas Robitaille
 * Thomas Spura
 * Thomas Weißschuh
 * Timothy O'Donnell
 * Tom Dimiduk
 * ugurthemaster
 * urielshaolin
 * v923z
 * Valentin Haenel
 * Victor Zverovich
 * W. Trevor King
 * y-p
 * Yoav Ram
 * Zbigniew Jędrzejewski-Szmek
 * Zoltán Vörös
 
 
 We closed a total of 1484 issues, 793 pull requests and 691 regular issues;
 this is the full list (generated with the script 
 :file:`tools/github_stats.py`):
 
 Pull Requests (793):
 
 * :ghpull:`3958`: doc update
 * :ghpull:`3965`: Fix ansi color code for background yellow
 * :ghpull:`3964`: Fix casing of message.
 * :ghpull:`3942`: Pass on install docs
 * :ghpull:`3962`: exclude IPython.lib.kernel in iptest
 * :ghpull:`3961`: Longpath test fix
 * :ghpull:`3905`: Remove references to 0.11 and 0.12 from config/overview.rst
 * :ghpull:`3951`: nbconvert: fixed latex characters not escaped properly in nbconvert
 * :ghpull:`3949`: log fatal error when PDF conversion fails
 * :ghpull:`3947`: nbconvert: Make writer & post-processor aliases case insensitive.
 * :ghpull:`3938`: Recompile css.
 * :ghpull:`3948`: sphinx and PDF tweaks
 * :ghpull:`3943`: nbconvert: Serve post-processor Windows fix
 * :ghpull:`3934`: nbconvert: fix logic of verbose flag in PDF post processor
 * :ghpull:`3929`: swallow enter event in rename dialog
 * :ghpull:`3924`: nbconvert: Backport fixes
 * :ghpull:`3925`: Replace --pylab flag with --matplotlib in usage
 * :ghpull:`3910`: Added explicit error message for missing configuration arguments.
 * :ghpull:`3913`: grffile to support spaces in notebook names
 * :ghpull:`3918`: added check_for_tornado, closes #3916
 * :ghpull:`3917`: change docs/examples refs to be just examples
 * :ghpull:`3908`: what's new tweaks
 * :ghpull:`3896`: two column quickhelp dialog, closes #3895
 * :ghpull:`3911`: explicitly load python mode before IPython mode
 * :ghpull:`3901`: don't force . relative path, fix #3897
 * :ghpull:`3891`: fix #3889
 * :ghpull:`3892`: Fix documentation of Kernel.stop_channels
 * :ghpull:`3888`: posixify paths for Windows latex
 * :ghpull:`3882`: quick fix for #3881
 * :ghpull:`3877`: don't use `shell=True` in PDF export
 * :ghpull:`3878`: minor template loading cleanup
 * :ghpull:`3855`: nbconvert: Filter tests
 * :ghpull:`3879`: finish 3870
 * :ghpull:`3870`: Fix for converting notebooks that contain unicode characters.
 * :ghpull:`3876`: Update parallel_winhpc.rst
 * :ghpull:`3872`: removing vim-ipython, since it has it's own repo
 * :ghpull:`3871`: updating docs
 * :ghpull:`3873`: remove old examples
 * :ghpull:`3868`: update CodeMirror component to 3.15
 * :ghpull:`3865`: Escape filename for pdflatex in nbconvert
 * :ghpull:`3861`: remove old external.js
 * :ghpull:`3864`: add keyboard shortcut to docs
 * :ghpull:`3834`: This PR fixes a few issues with nbconvert tests
 * :ghpull:`3840`: prevent profile_dir from being undefined
 * :ghpull:`3859`: Add "An Afternoon Hack" to docs
 * :ghpull:`3854`: Catch errors filling readline history on startup
 * :ghpull:`3857`: Delete extra auto
 * :ghpull:`3845`: nbconvert: Serve from original build directory
 * :ghpull:`3846`: Add basic logging to nbconvert
 * :ghpull:`3850`: add missing store_history key to Notebook execute_requests
 * :ghpull:`3844`: update payload source
 * :ghpull:`3830`: mention metadata / display_data similarity in pyout spec
 * :ghpull:`3848`: fix incorrect `empty-docstring`
 * :ghpull:`3836`: Parse markdown correctly when mathjax is disabled
 * :ghpull:`3849`: skip a failing test on windows
 * :ghpull:`3828`: signature_scheme lives in Session
 * :ghpull:`3831`: update nbconvert doc with new CLI
 * :ghpull:`3822`: add output flag to nbconvert
 * :ghpull:`3780`: Added serving the output directory if html-based format are selected.
 * :ghpull:`3764`: Cleanup nbconvert templates
 * :ghpull:`3829`: remove now-duplicate 'this is dev' note
 * :ghpull:`3814`: add `ConsoleWidget.execute_on_complete_input` flag
 * :ghpull:`3826`: try rtfd
 * :ghpull:`3821`: add sphinx prolog
 * :ghpull:`3817`: relax timeouts in terminal console and tests
 * :ghpull:`3825`: fix more tests that fail when pandoc is missing
 * :ghpull:`3824`: don't set target on internal markdown links
 * :ghpull:`3816`: s/pylab/matplotlib in docs
 * :ghpull:`3812`: Describe differences between start_ipython and embed
 * :ghpull:`3805`: Print View has been removed
 * :ghpull:`3820`: Make it clear that 1.0 is not released yet
 * :ghpull:`3784`: nbconvert: Export flavors & PDF writer (ipy dev meeting)
 * :ghpull:`3800`: semantic-versionify version number for non-releases
 * :ghpull:`3802`: Documentation .txt to .rst
 * :ghpull:`3765`: cleanup terminal console iopub handling
 * :ghpull:`3720`: Fix for #3719
 * :ghpull:`3787`: re-raise KeyboardInterrupt in raw_input
 * :ghpull:`3770`: Organizing reveal's templates.
 * :ghpull:`3751`: Use link(2) when possible in nbconvert
 * :ghpull:`3792`: skip tests that require pandoc
 * :ghpull:`3782`: add Importing Notebooks example
 * :ghpull:`3752`: nbconvert: Add cwd to sys.path
 * :ghpull:`3789`: fix raw_input in qtconsole
 * :ghpull:`3756`: document the wire protocol
 * :ghpull:`3749`: convert IPython syntax to Python syntax in nbconvert python template
 * :ghpull:`3793`: Closes #3788
 * :ghpull:`3794`: Change logo link to ipython.org
 * :ghpull:`3746`: Raise a named exception when pandoc is missing
 * :ghpull:`3781`: comply with the message spec in the notebook
 * :ghpull:`3779`: remove bad `if logged_in` preventing new-notebook without login
 * :ghpull:`3743`: remove notebook read-only view
 * :ghpull:`3732`: add delay to autosave in beforeunload
 * :ghpull:`3761`: Added rm_math_space to markdown cells in the basichtml.tpl to be rendered ok by mathjax after the nbconvertion.
 * :ghpull:`3758`: nbconvert: Filter names cleanup
 * :ghpull:`3769`: Add configurability to  tabcompletion timeout
 * :ghpull:`3771`: Update px pylab test to match new output of pylab
 * :ghpull:`3741`: better message when notebook format is not supported
 * :ghpull:`3753`: document Ctrl-C not working in ipython kernel
 * :ghpull:`3766`: handle empty metadata in pyout messages more gracefully.
 * :ghpull:`3736`: my attempt to fix #3735
 * :ghpull:`3759`: nbconvert: Provide a more useful error for invalid use case.
 * :ghpull:`3760`: nbconvert: Allow notebook filenames without their extensions
 * :ghpull:`3750`: nbconvert: Add cwd to default templates search path.
 * :ghpull:`3748`: Update nbconvert docs
 * :ghpull:`3734`: Nbconvert: Export extracted files into `nbname_files` subdirectory
 * :ghpull:`3733`: Nicer message when pandoc is missing, closes #3730
 * :ghpull:`3722`: fix two failing test in IPython.lib
 * :ghpull:`3704`: Start what's new for 1.0
 * :ghpull:`3705`: Complete rewrite of IPython Notebook documentation: docs/source/interactive/htmlnotebook.txt
 * :ghpull:`3709`: Docs cleanup
 * :ghpull:`3716`: raw_input fixes for kernel restarts
 * :ghpull:`3683`: use `%matplotlib` in example notebooks
 * :ghpull:`3686`: remove quarantine
 * :ghpull:`3699`: svg2pdf unicode fix
 * :ghpull:`3695`: fix SVG2PDF
 * :ghpull:`3685`: fix Pager.detach
 * :ghpull:`3675`: document new dependencies
 * :ghpull:`3690`: Fixing some css minors in full_html and reveal.
 * :ghpull:`3671`: nbconvert tests
 * :ghpull:`3692`: Fix rename notebook - show error with invalid name
 * :ghpull:`3409`: Prevent qtconsole frontend freeze on lots of output.
 * :ghpull:`3660`: refocus active cell on dialog close
 * :ghpull:`3598`: Statelessify mathjaxutils
 * :ghpull:`3673`: enable comment/uncomment selection
 * :ghpull:`3677`: remove special-case in get_home_dir for frozen dists
 * :ghpull:`3674`: add CONTRIBUTING.md
 * :ghpull:`3670`: use Popen command list for ipexec
 * :ghpull:`3568`: pylab import adjustments
 * :ghpull:`3559`: add create.Cell and delete.Cell js events
 * :ghpull:`3606`: push cell magic to the head of the transformer line
 * :ghpull:`3607`: NbConvert: Writers, No YAML, and stuff...
 * :ghpull:`3665`: Pywin32 skips
 * :ghpull:`3669`: set default client_class for QtKernelManager
 * :ghpull:`3662`: add strip_encoding_cookie transformer
 * :ghpull:`3641`: increase patience for slow kernel startup in tests
 * :ghpull:`3651`: remove a bunch of unused `default_config_file` assignments
 * :ghpull:`3630`: CSS adjustments
 * :ghpull:`3645`: Don't require HistoryManager to have a shell
 * :ghpull:`3643`: don't assume tested ipython is on the PATH
 * :ghpull:`3654`: fix single-result AsyncResults
 * :ghpull:`3601`: Markdown in heading cells (take 2)
 * :ghpull:`3652`: Remove old `docs/examples`
 * :ghpull:`3621`: catch any exception appending output
 * :ghpull:`3585`: don't blacklist builtin names
 * :ghpull:`3647`: Fix `frontend` deprecation warnings in several examples
 * :ghpull:`3649`: fix AsyncResult.get_dict for single result
 * :ghpull:`3648`: Fix store magic test 
 * :ghpull:`3650`: Fix, config_file_name was ignored
 * :ghpull:`3640`: Gcf.get_active() can return None
 * :ghpull:`3571`: Added shorcuts to split cell, merge cell above and merge cell below.
 * :ghpull:`3635`: Added missing slash to print-pdf call.
 * :ghpull:`3487`: Drop patch for compatibility with pyreadline 1.5
 * :ghpull:`3338`: Allow filename with extension in find_cmd in Windows.
 * :ghpull:`3628`: Fix test for Python 3 on Windows.
 * :ghpull:`3642`: Fix typo in docs
 * :ghpull:`3627`: use DEFAULT_STATIC_FILES_PATH in a test instead of package dir
 * :ghpull:`3624`: fix some unicode in zmqhandlers
 * :ghpull:`3460`: Set calling program to UNKNOWN, when argv not in sys
 * :ghpull:`3632`: Set calling program to UNKNOWN, when argv not in sys (take #2)
 * :ghpull:`3629`: Use new entry point for python -m IPython
 * :ghpull:`3626`: passing cell to showInPager, closes #3625
 * :ghpull:`3618`: expand terminal color support
 * :ghpull:`3623`: raise UsageError for unsupported GUI backends
 * :ghpull:`3071`: Add magic function %drun to run code in debugger
 * :ghpull:`3608`: a nicer error message when using %pylab magic
 * :ghpull:`3592`: add extra_config_file
 * :ghpull:`3612`: updated .mailmap
 * :ghpull:`3616`: Add examples for interactive use of MPI.
 * :ghpull:`3615`: fix regular expression for ANSI escapes
 * :ghpull:`3586`: Corrected a typo in the format string for strftime the sphinx.py transformer of nbconvert
 * :ghpull:`3611`: check for markdown no longer needed, closes #3610
 * :ghpull:`3555`: Simplify caching of modules with %run
 * :ghpull:`3583`: notebook small things
 * :ghpull:`3594`: Fix duplicate completion in notebook
 * :ghpull:`3600`: parallel: Improved logging for errors during BatchSystemLauncher.stop
 * :ghpull:`3595`: Revert "allow markdown in heading cells"
 * :ghpull:`3538`: add IPython.start_ipython
 * :ghpull:`3562`: Allow custom nbconvert template loaders
 * :ghpull:`3582`: pandoc adjustments
 * :ghpull:`3560`: Remove max_msg_size
 * :ghpull:`3591`: Refer to Setuptools instead of Distribute
 * :ghpull:`3590`: IPython.sphinxext needs an __init__.py
 * :ghpull:`3581`: Added the possibility to read a custom.css file for tweaking the final html in full_html and reveal templates.
 * :ghpull:`3576`: Added support for markdown in heading cells when they are nbconverted.
 * :ghpull:`3575`: tweak `run -d` message to 'continue execution'
 * :ghpull:`3569`: add PYTHONSTARTUP to startup files
 * :ghpull:`3567`: Trigger a single event on js app initilized
 * :ghpull:`3565`: style.min.css shoudl always exist...
 * :ghpull:`3531`: allow markdown in heading cells
 * :ghpull:`3577`: Simplify codemirror ipython-mode
 * :ghpull:`3495`: Simplified regexp, and suggestions for clearer regexps.
 * :ghpull:`3578`: Use adjustbox to specify figure size in nbconvert -> latex
 * :ghpull:`3572`: Skip import irunner test on Windows.
 * :ghpull:`3574`: correct static path for CM modes autoload
 * :ghpull:`3558`: Add IPython.sphinxext
 * :ghpull:`3561`: mention double-control-C to stop notebook server
 * :ghpull:`3566`: fix event names
 * :ghpull:`3564`: Remove trivial nbconvert example
 * :ghpull:`3540`: allow cython cache dir to be deleted
 * :ghpull:`3527`: cleanup stale, unused exceptions in parallel.error
 * :ghpull:`3529`: ensure raw_input returns str in zmq shell
 * :ghpull:`3541`: respect image size metadata in qtconsole
 * :ghpull:`3550`: Fixing issue preventing the correct read of images by full_html and reveal exporters.
 * :ghpull:`3557`: open markdown links in new tabs
 * :ghpull:`3556`: remove mention of nonexistent `_margv` in macro
 * :ghpull:`3552`: set overflow-x: hidden on Firefox only
 * :ghpull:`3554`: Fix missing import os in latex exporter.
 * :ghpull:`3546`: Don't hardcode **latex** posix paths in nbconvert
 * :ghpull:`3551`: fix path prefix in nbconvert
 * :ghpull:`3533`: Use a CDN to get reveal.js library.
 * :ghpull:`3498`: When a notebook is written to file, name the metadata name u''.
 * :ghpull:`3548`: Change to standard save icon in Notebook toolbar
 * :ghpull:`3539`: Don't hardcode posix paths in nbconvert
 * :ghpull:`3508`: notebook supports raw_input and %debug now
 * :ghpull:`3526`: ensure 'default' is first in cluster profile list
 * :ghpull:`3525`: basic timezone info
 * :ghpull:`3532`: include nbconvert templates in installation
 * :ghpull:`3515`: update CodeMirror component to 3.14
 * :ghpull:`3513`: add 'No Checkpoints' to Revert menu
 * :ghpull:`3536`: format positions are required in Python 2.6.x
 * :ghpull:`3521`: Nbconvert fix, silent fail if template doesn't exist
 * :ghpull:`3530`: update %store magic docstring
 * :ghpull:`3528`: fix local mathjax with custom base_project_url
 * :ghpull:`3518`: Clear up unused imports
 * :ghpull:`3506`: %store -r restores saved aliases and directory history, as well as variables
 * :ghpull:`3516`: make css highlight style configurable
 * :ghpull:`3523`: Exclude frontend shim from docs build
 * :ghpull:`3514`: use bootstrap `disabled` instead of `ui-state-disabled`
 * :ghpull:`3520`: Added relative import of RevealExporter to __init__.py inside exporters module
 * :ghpull:`3507`: fix HTML capitalization in nbconvert exporter classes
 * :ghpull:`3512`: fix nbconvert filter validation
 * :ghpull:`3511`: Get Tracer working after ipapi.get replaced with get_ipython
 * :ghpull:`3510`: use `window.onbeforeunload=` for nav-away warning
 * :ghpull:`3504`: don't use parent=self in handlers
 * :ghpull:`3500`: Merge nbconvert into IPython
 * :ghpull:`3478`: restore "unsaved changes" warning on unload
 * :ghpull:`3493`: add a dialog when the kernel is auto-restarted
 * :ghpull:`3488`: Add test suite for autoreload extension
 * :ghpull:`3484`: Catch some pathological cases inside oinspect
 * :ghpull:`3481`: Display R errors without Python traceback
 * :ghpull:`3468`: fix `%magic` output
 * :ghpull:`3430`: add parent to Configurable
 * :ghpull:`3491`: Remove unexpected keyword parameter to remove_kernel
 * :ghpull:`3485`: SymPy has changed its recommended way to initialize printing
 * :ghpull:`3486`: Add test for non-ascii characters in docstrings
 * :ghpull:`3483`: Inputtransformer: Allow classic prompts without space
 * :ghpull:`3482`: Use an absolute path to iptest, because the tests are not always run from $IPYTHONDIR.
 * :ghpull:`3381`: enable 2x (retina) display
 * :ghpull:`3450`: Flatten IPython.frontend
 * :ghpull:`3477`: pass config to subapps
 * :ghpull:`3466`: Kernel fails to start when username has non-ascii characters
 * :ghpull:`3465`: Add HTCondor bindings to IPython.parallel
 * :ghpull:`3463`: fix typo, closes #3462
 * :ghpull:`3456`: Notice for users who disable javascript
 * :ghpull:`3453`: fix cell execution in firefox, closes #3447
 * :ghpull:`3393`: [WIP] bootstrapify
 * :ghpull:`3440`: Fix installing mathjax from downloaded file via command line
 * :ghpull:`3431`: Provide means for starting the Qt console maximized and with the menu bar hidden
 * :ghpull:`3425`: base IPClusterApp inherits from BaseIPythonApp
 * :ghpull:`3433`: Update IPython\external\path\__init__.py
 * :ghpull:`3298`: Some fixes in IPython Sphinx directive
 * :ghpull:`3428`: process escapes in mathjax
 * :ghpull:`3420`: thansk -> thanks
 * :ghpull:`3416`: Fix doc: "principle" not "principal"
 * :ghpull:`3413`: more unique filename for test
 * :ghpull:`3364`: Inject requirejs in notebook and start using it.
 * :ghpull:`3390`: Fix %paste with blank lines
 * :ghpull:`3403`: fix creating config objects from dicts
 * :ghpull:`3401`: rollback #3358
 * :ghpull:`3373`: make cookie_secret configurable
 * :ghpull:`3307`: switch default ws_url logic to js side
 * :ghpull:`3392`: Restore anchor link on h2-h6
 * :ghpull:`3369`: Use different treshold for (auto)scroll in output
 * :ghpull:`3370`: normalize unicode notebook filenames
 * :ghpull:`3372`: base default cookie name on request host+port
 * :ghpull:`3378`: disable CodeMirror drag/drop on Safari
 * :ghpull:`3358`: workaround spurious CodeMirror scrollbars
 * :ghpull:`3371`: make setting the notebook dirty flag an event
 * :ghpull:`3366`: remove long-dead zmq frontend.py and completer.py
 * :ghpull:`3382`: cull Session digest history
 * :ghpull:`3330`: Fix get_ipython_dir when $HOME is /
 * :ghpull:`3319`: IPEP 13: user-expressions and user-variables
 * :ghpull:`3384`: comments in tools/gitwash_dumper.py changed (''' to """)
 * :ghpull:`3387`: Make submodule checks work under Python 3.
 * :ghpull:`3357`: move anchor-link off of heading text
 * :ghpull:`3351`: start basic tests of ipcluster Launchers
 * :ghpull:`3377`: allow class.__module__ to be None
 * :ghpull:`3340`: skip submodule check in package managers
 * :ghpull:`3328`: decode subprocess output in launchers
 * :ghpull:`3368`: Reenable bracket matching
 * :ghpull:`3356`: Mpr fixes
 * :ghpull:`3336`: Use new input transformation API in %time magic
 * :ghpull:`3325`: Organize the JS and less files by component.
 * :ghpull:`3342`: fix test_find_cmd_python
 * :ghpull:`3354`: catch socket.error in utils.localinterfaces
 * :ghpull:`3341`: fix default cluster count
 * :ghpull:`3286`: don't use `get_ipython` from builtins in library code
 * :ghpull:`3333`: notebookapp: add missing whitespace to warnings
 * :ghpull:`3323`: Strip prompts even if the prompt isn't present on the first line.
 * :ghpull:`3321`: Reorganize the python/server side of the notebook
 * :ghpull:`3320`: define `__file__` in config files
 * :ghpull:`3317`: rename `%%file` to `%%writefile`
 * :ghpull:`3304`: set unlimited HWM for all relay devices
 * :ghpull:`3315`: Update Sympy_printing extension load
 * :ghpull:`3310`: further clarify Image docstring
 * :ghpull:`3285`: load extensions in builtin trap
 * :ghpull:`3308`: Speed up AsyncResult._wait_for_outputs(0)
 * :ghpull:`3294`: fix callbacks as optional in js kernel.execute
 * :ghpull:`3276`: Fix: "python ABS/PATH/TO/ipython.py" fails
 * :ghpull:`3301`: allow python3 tests without python installed
 * :ghpull:`3282`: allow view.map to work with a few more things
 * :ghpull:`3284`: remove `ipython.py` entry point
 * :ghpull:`3281`: fix ignored IOPub messages with no parent
 * :ghpull:`3275`: improve submodule messages / git hooks
 * :ghpull:`3239`: Allow "x" icon and esc key to close pager in notebook
 * :ghpull:`3290`: Improved heartbeat controller to engine monitoring for long running tasks
 * :ghpull:`3142`: Better error message when CWD doesn't exist on startup
 * :ghpull:`3066`: Add support for relative import to %run -m (fixes #2727)
 * :ghpull:`3269`: protect highlight.js against unknown languages
 * :ghpull:`3267`: add missing return
 * :ghpull:`3101`: use marked / highlight.js instead of pagedown and prettify
 * :ghpull:`3264`: use https url for submodule
 * :ghpull:`3263`: fix set_last_checkpoint when no checkpoint
 * :ghpull:`3258`: Fix submodule location in setup.py
 * :ghpull:`3254`: fix a few URLs from previous PR
 * :ghpull:`3240`: remove js components from the repo
 * :ghpull:`3158`: IPEP 15: autosave the notebook
 * :ghpull:`3252`: move images out of _static folder into _images
 * :ghpull:`3251`: Fix for cell magics in Qt console
 * :ghpull:`3250`: Added a simple __html__() method to the HTML class
 * :ghpull:`3249`: remove copy of sphinx inheritance_diagram.py
 * :ghpull:`3235`: Remove the unused print notebook view
 * :ghpull:`3238`: Improve the design of the tab completion UI
 * :ghpull:`3242`: Make changes of Application.log_format effective
 * :ghpull:`3219`: Workaround so only one CTRL-C is required for a new prompt in --gui=qt
 * :ghpull:`3190`: allow formatters to specify metadata
 * :ghpull:`3231`: improve discovery of public IPs
 * :ghpull:`3233`: check prefixes for swallowing kernel args
 * :ghpull:`3234`: Removing old autogrow JS code.
 * :ghpull:`3232`: Update to CodeMirror 3 and start to ship our components
 * :ghpull:`3229`: The HTML output type accidentally got removed from the OutputArea.
 * :ghpull:`3228`: Typo in IPython.Parallel documentation
 * :ghpull:`3226`: Text in rename dialog was way too big - making it <p>.
 * :ghpull:`3225`: Removing old restuctured text handler and web service.
 * :ghpull:`3222`: make BlockingKernelClient the default Client
 * :ghpull:`3223`: add missing mathjax_url to new settings dict
 * :ghpull:`3089`: add stdin to the notebook
 * :ghpull:`3221`: Remove references to HTMLCell (dead code)
-* :ghpull:`3205`: add ignored *args to HasTraits constructor
+* :ghpull:`3205`: add ignored ``*args`` to HasTraits constructor
 * :ghpull:`3088`: cleanup IPython handler settings
 * :ghpull:`3201`: use much faster regexp for ansi coloring
 * :ghpull:`3220`: avoid race condition in profile creation
 * :ghpull:`3011`: IPEP 12: add KernelClient
 * :ghpull:`3217`: informative error when trying to load directories
 * :ghpull:`3174`: Simple class
 * :ghpull:`2979`: CM configurable Take 2
 * :ghpull:`3215`: Updates storemagic extension to allow for specifying variable name to load
 * :ghpull:`3181`: backport If-Modified-Since fix from tornado
 * :ghpull:`3200`: IFrame (VimeoVideo, ScribdDocument, ...) 
 * :ghpull:`3186`: Fix small inconsistency in nbconvert: etype -> ename
 * :ghpull:`3212`: Fix issue #2563, "core.profiledir.check_startup_dir() doesn't work inside py2exe'd installation"
 * :ghpull:`3211`: Fix inheritance_diagram Sphinx extension for Sphinx 1.2
 * :ghpull:`3208`: Update link to extensions index
 * :ghpull:`3203`: Separate InputSplitter for transforming whole cells
 * :ghpull:`3189`: Improve completer
 * :ghpull:`3194`: finish up PR #3116
 * :ghpull:`3188`: Add new keycodes
 * :ghpull:`2695`: Key the root modules cache by sys.path entries.
 * :ghpull:`3182`: clarify %%file docstring
 * :ghpull:`3163`: BUG: Fix the set and frozenset pretty printer to handle the empty case correctly
 * :ghpull:`3180`: better UsageError for cell magic with no body
 * :ghpull:`3184`: Cython cache
 * :ghpull:`3175`: Added missing s
 * :ghpull:`3173`: Little bits of documentation cleanup
 * :ghpull:`2635`: Improve Windows start menu shortcuts (#2)
 * :ghpull:`3172`: Add missing import in IPython parallel magics example
 * :ghpull:`3170`: default application logger shouldn't propagate
 * :ghpull:`3159`: Autocompletion for zsh
 * :ghpull:`3105`: move DEFAULT_STATIC_FILES_PATH to IPython.html
 * :ghpull:`3144`: minor bower tweaks
 * :ghpull:`3141`: Default color output for ls on OSX
 * :ghpull:`3137`: fix dot syntax error in inheritance diagram
 * :ghpull:`3072`: raise UnsupportedOperation on iostream.fileno()
 * :ghpull:`3147`: Notebook support for a reverse proxy which handles SSL
 * :ghpull:`3152`: make qtconsole size at startup configurable
 * :ghpull:`3162`: adding stream kwarg to current.new_output
 * :ghpull:`2981`: IPEP 10: kernel side filtering of display formats
 * :ghpull:`3058`: add redirect handler for notebooks by name
 * :ghpull:`3041`: support non-modules in @require
 * :ghpull:`2447`: Stateful line transformers
 * :ghpull:`3108`: fix some O(N) and O(N^2) operations in parallel.map
 * :ghpull:`2791`: forward stdout from forked processes
 * :ghpull:`3157`: use Python 3-style for pretty-printed sets
 * :ghpull:`3148`: closes #3045, #3123 for tornado < version 3.0
 * :ghpull:`3143`: minor heading-link tweaks
 * :ghpull:`3136`: Strip useless ANSI escape codes in notebook
 * :ghpull:`3126`: Prevent errors when pressing arrow keys in an empty notebook
 * :ghpull:`3135`: quick dev installation instructions
 * :ghpull:`2889`: Push pandas dataframes to R magic
 * :ghpull:`3068`: Don't monkeypatch doctest during IPython startup.
 * :ghpull:`3133`: fix argparse version check
 * :ghpull:`3102`: set `spellcheck=false` in CodeCell inputarea
 * :ghpull:`3064`: add anchors to heading cells
 * :ghpull:`3097`: PyQt 4.10: use self._document = self.document()
 * :ghpull:`3117`: propagate automagic change to shell
 * :ghpull:`3118`: don't give up on weird os names
 * :ghpull:`3115`: Fix example
 * :ghpull:`2640`: fix quarantine/ipy_editors.py
 * :ghpull:`3070`: Add info make target that was missing in old Sphinx
 * :ghpull:`3082`: A few small patches to image handling
 * :ghpull:`3078`: fix regular expression for detecting links in stdout
 * :ghpull:`3054`: restore default behavior for automatic cluster size
 * :ghpull:`3073`: fix ipython usage text
 * :ghpull:`3083`: fix DisplayMagics.html docstring
 * :ghpull:`3080`: noted sub_channel being renamed to iopub_channel
 * :ghpull:`3079`: actually use IPKernelApp.kernel_class
 * :ghpull:`3076`: Improve notebook.js documentation
 * :ghpull:`3063`: add missing `%%html` magic
 * :ghpull:`3075`: check for SIGUSR1 before using it, closes #3074
 * :ghpull:`3051`: add width:100% to vbox for webkit / FF consistency
 * :ghpull:`2999`: increase registration timeout
 * :ghpull:`2997`: fix DictDB default size limit
 * :ghpull:`3033`: on resume, print server info again
 * :ghpull:`3062`: test double pyximport
 * :ghpull:`3046`: cast kernel cwd to bytes on Python 2 on Windows
 * :ghpull:`3038`: remove xml from notebook magic docstrings
 * :ghpull:`3032`: fix time format to international time format
 * :ghpull:`3022`: Fix test for Windows
 * :ghpull:`3024`: changed instances of 'outout' to 'output' in alt texts
 * :ghpull:`3013`: py3 workaround for reload in cythonmagic
 * :ghpull:`2961`: time magic: shorten unnecessary output on windows
 * :ghpull:`2987`: fix local files examples in markdown
 * :ghpull:`2998`: fix css in .output_area pre
 * :ghpull:`3003`: add $include /etc/inputrc to suggested ~/.inputrc
 * :ghpull:`2957`: Refactor qt import logic. Fixes #2955
 * :ghpull:`2994`: expanduser on %%file targets
 * :ghpull:`2983`: fix run-all (that-> this)
 * :ghpull:`2964`: fix count when testing composite error output
 * :ghpull:`2967`: shows entire session history when only startsess is given
 * :ghpull:`2942`: Move CM IPython theme out of codemirror folder
 * :ghpull:`2929`: Cleanup cell insertion
 * :ghpull:`2933`: Minordocupdate
 * :ghpull:`2968`: fix notebook deletion.
 * :ghpull:`2966`: Added assert msg to extract_hist_ranges()
 * :ghpull:`2959`: Add command to trim the history database.
 * :ghpull:`2681`: Don't enable pylab mode, when matplotlib is not importable
 * :ghpull:`2901`: Fix inputhook_wx on osx
 * :ghpull:`2871`: truncate potentially long CompositeErrors
 * :ghpull:`2951`: use istype on lists/tuples
 * :ghpull:`2946`: fix qtconsole history logic for end-of-line
 * :ghpull:`2954`: fix logic for append_javascript
 * :ghpull:`2941`: fix baseUrl
 * :ghpull:`2903`: Specify toggle value on cell line number
 * :ghpull:`2911`: display order in output area configurable
 * :ghpull:`2897`: Dont rely on BaseProjectUrl data in body tag
 * :ghpull:`2894`: Cm configurable
 * :ghpull:`2927`: next release will be 1.0
 * :ghpull:`2932`: Simplify using notebook static files from external code
 * :ghpull:`2915`: added small config section to notebook docs page
 * :ghpull:`2924`: safe_run_module: Silence SystemExit codes 0 and None.
 * :ghpull:`2906`: Unpatch/Monkey patch CM
 * :ghpull:`2921`: add menu item for undo delete cell
 * :ghpull:`2917`: Don't add logging handler if one already exists.
 * :ghpull:`2910`: Respect DB_IP and DB_PORT in mongodb tests
 * :ghpull:`2926`: Don't die if stderr/stdout do not support set_parent() #2925
 * :ghpull:`2885`: get monospace pager back
 * :ghpull:`2876`: fix celltoolbar layout on FF
 * :ghpull:`2904`: Skip remaining IPC test on Windows
 * :ghpull:`2908`: fix last remaining KernelApp reference
 * :ghpull:`2905`: fix a few remaining KernelApp/IPKernelApp changes
 * :ghpull:`2900`: Don't assume test case for %time will finish in 0 time
 * :ghpull:`2893`: exclude fabfile from tests
 * :ghpull:`2884`: Correct import for kernelmanager on Windows
 * :ghpull:`2882`: Utils cleanup
 * :ghpull:`2883`: Don't call ast.fix_missing_locations unless the AST could have been modified
 * :ghpull:`2855`: time(it) magic: Implement minutes/hour formatting and "%%time" cell magic
 * :ghpull:`2874`: Empty cell warnings
 * :ghpull:`2819`: tweak history prefix search (up/^p) in qtconsole
 * :ghpull:`2868`: Import performance
 * :ghpull:`2877`: minor css fixes
 * :ghpull:`2880`: update examples docs with kernel move
 * :ghpull:`2878`: Pass host environment on to kernel
 * :ghpull:`2599`: func_kw_complete for builtin and cython with embededsignature=True using docstring
 * :ghpull:`2792`: Add key "unique" to history_request protocol
 * :ghpull:`2872`: fix payload keys
 * :ghpull:`2869`: Fixing styling of toolbar selects on FF.
 * :ghpull:`2708`: Less css
 * :ghpull:`2854`: Move kernel code into IPython.kernel
 * :ghpull:`2864`: Fix %run -t -N<N> TypeError
 * :ghpull:`2852`: future pyzmq compatibility
 * :ghpull:`2863`: whatsnew/version0.9.txt: Fix '~./ipython' -> '~/.ipython' typo
 * :ghpull:`2861`: add missing KernelManager to ConsoleApp class list
 * :ghpull:`2850`: Consolidate host IP detection in utils.localinterfaces
 * :ghpull:`2859`: Correct docstring of ipython.py
 * :ghpull:`2831`: avoid string version comparisons in external.qt
 * :ghpull:`2844`: this should address the failure in #2732
 * :ghpull:`2849`: utils/data: Use list comprehension for uniq_stable()
 * :ghpull:`2839`: add jinja to install docs / setup.py
 * :ghpull:`2841`: Miscellaneous docs fixes
 * :ghpull:`2811`: Still more KernelManager cleanup
 * :ghpull:`2820`: add '=' to greedy completer delims
 * :ghpull:`2818`: log user tracebacks in the kernel (INFO-level)
 * :ghpull:`2828`: Clean up notebook Javascript
 * :ghpull:`2829`: avoid comparison error in dictdb hub history
 * :ghpull:`2830`: BUG: Opening parenthesis after non-callable raises ValueError
 * :ghpull:`2718`: try to fallback to pysqlite2.dbapi2 as sqlite3 in core.history
 * :ghpull:`2816`: in %edit, don't save "last_call" unless last call succeeded
 * :ghpull:`2817`: change ol format order
 * :ghpull:`2537`: Organize example notebooks
 * :ghpull:`2815`: update release/authors
 * :ghpull:`2808`: improve patience for slow Hub in client tests
 * :ghpull:`2812`: remove nonfunctional `-la` short arg in cython magic
 * :ghpull:`2810`: remove dead utils.upgradedir
 * :ghpull:`1671`: __future__ environments
 * :ghpull:`2804`: skip ipc tests on Windows
 * :ghpull:`2789`: Fixing styling issues with CellToolbar.
 * :ghpull:`2805`: fix KeyError creating ZMQStreams in notebook
 * :ghpull:`2775`: General cleanup of kernel manager code.
 * :ghpull:`2340`: Initial Code to reduce parallel.Client caching
 * :ghpull:`2799`: Exit code
 * :ghpull:`2800`: use `type(obj) is cls` as switch when canning
 * :ghpull:`2801`: Fix a breakpoint bug
 * :ghpull:`2795`: Remove outdated code from extensions.autoreload
 * :ghpull:`2796`: P3K: fix cookie parsing under Python 3.x (+ duplicate import is removed)
 * :ghpull:`2724`: In-process kernel support (take 3)
 * :ghpull:`2687`: [WIP] Metaui slideshow
 * :ghpull:`2788`: Chrome frame awareness
 * :ghpull:`2649`: Add version_request/reply messaging protocol
 * :ghpull:`2753`: add `%%px --local` for local execution
 * :ghpull:`2783`: Prefilter shouldn't touch execution_count
 * :ghpull:`2333`: UI For Metadata
 * :ghpull:`2396`: create a ipynbv3 json schema and a validator
 * :ghpull:`2757`: check for complete pyside presence before trying to import
 * :ghpull:`2782`: Allow the %run magic with '-b' to specify a file.
 * :ghpull:`2778`: P3K: fix DeprecationWarning under Python 3.x 
 * :ghpull:`2776`: remove non-functional View.kill method
 * :ghpull:`2755`: can interactively defined classes
 * :ghpull:`2774`: Removing unused code in the notebook MappingKernelManager.
 * :ghpull:`2773`: Fixed minor typo causing AttributeError to be thrown.
 * :ghpull:`2609`: Add 'unique' option to history_request messaging protocol
 * :ghpull:`2769`: Allow shutdown when no engines are registered
 * :ghpull:`2766`: Define __file__ when we %edit a real file.
 * :ghpull:`2476`: allow %edit <variable> to work when interactively defined
 * :ghpull:`2763`: Reset readline delimiters after loading rmagic.
 * :ghpull:`2460`: Better handling of `__file__` when running scripts.
 * :ghpull:`2617`: Fix for `units` argument. Adds a `res` argument.
 * :ghpull:`2738`: Unicode content crashes the pager (console)
 * :ghpull:`2749`: Tell Travis CI to test on Python 3.3 as well
 * :ghpull:`2744`: Don't show 'try %paste' message while using magics
 * :ghpull:`2728`: shift tab for tooltip
 * :ghpull:`2741`: Add note to `%cython` Black-Scholes example warning of missing erf.
 * :ghpull:`2743`: BUG: Octavemagic inline plots not working on Windows: Fixed
 * :ghpull:`2740`: Following #2737 this error is now a name error
 * :ghpull:`2737`: Rmagic: error message when moving an non-existant variable from python to R
 * :ghpull:`2723`: diverse fixes for project url
 * :ghpull:`2731`: %Rpush: Look for variables in the local scope first.
 * :ghpull:`2544`: Infinite loop when multiple debuggers have been attached.
 * :ghpull:`2726`: Add qthelp docs creation
 * :ghpull:`2730`: added blockquote CSS
 * :ghpull:`2729`: Fix Read the doc build, Again
 * :ghpull:`2446`: [alternate 2267] Offline mathjax
 * :ghpull:`2716`: remove unexisting headings level
 * :ghpull:`2717`: One liner to fix debugger printing stack traces when lines of context are larger than source.
 * :ghpull:`2713`: Doc bugfix: user_ns is not an attribute of Magic objects.
 * :ghpull:`2690`: Fix 'import '... completion for py3 & egg files.
 * :ghpull:`2691`: Document OpenMP in %%cython magic
 * :ghpull:`2699`: fix jinja2 rendering for password protected notebooks
 * :ghpull:`2700`: Skip notebook testing if jinja2 is not available.
 * :ghpull:`2692`: Add %%cython magics to generated documentation.
 * :ghpull:`2685`: Fix pretty print of types when `__module__` is not available.
 * :ghpull:`2686`: Fix tox.ini
 * :ghpull:`2604`: Backslashes are misinterpreted as escape-sequences by the R-interpreter.
 * :ghpull:`2689`: fix error in doc (arg->kwarg) and pep-8
 * :ghpull:`2683`: for downloads, replaced window.open with window.location.assign
 * :ghpull:`2659`: small bugs in js are fixed
 * :ghpull:`2363`: Refactor notebook templates to use Jinja2
 * :ghpull:`2662`: qtconsole: wrap argument list in tooltip to match width of text body
 * :ghpull:`2328`: addition of classes to generate a link or list of links from files local to the IPython HTML notebook
 * :ghpull:`2668`: pylab_not_importable: Catch all exceptions, not just RuntimeErrors.
 * :ghpull:`2663`: Fix issue #2660: parsing of help and version arguments
 * :ghpull:`2656`: Fix irunner tests when $PYTHONSTARTUP is set
 * :ghpull:`2312`: Add bracket matching to code cells in notebook
 * :ghpull:`2571`: Start to document Javascript
 * :ghpull:`2641`: undefinied that -> this
 * :ghpull:`2638`: Fix %paste in Python 3 on Mac
 * :ghpull:`2301`: Ast transfomers
 * :ghpull:`2616`: Revamp API docs
 * :ghpull:`2572`: Make 'Paste Above' the default paste behavior.
 * :ghpull:`2574`: Fix #2244
 * :ghpull:`2582`: Fix displaying history when output cache is disabled.
 * :ghpull:`2591`: Fix for Issue #2584 
 * :ghpull:`2526`: Don't kill paramiko tunnels when receiving ^C
 * :ghpull:`2559`: Add psource, pfile, pinfo2 commands to ipdb.
 * :ghpull:`2546`: use 4 Pythons to build 4 Windows installers
 * :ghpull:`2561`: Fix display of plain text containing multiple carriage returns before line feed
 * :ghpull:`2549`: Add a simple 'undo' for cell deletion.
 * :ghpull:`2525`: Add event to kernel execution/shell reply.
 * :ghpull:`2554`: Avoid stopping in ipdb until we reach the main script.
 * :ghpull:`2404`: Option to limit search result in history magic command
 * :ghpull:`2294`: inputhook_qt4: Use QEventLoop instead of starting up the QCoreApplication
 * :ghpull:`2233`: Refactored Drag and Drop Support in Qt Console
 * :ghpull:`1747`: switch between hsplit and vsplit paging (request for feedback)
 * :ghpull:`2530`: Adding time offsets to the video
 * :ghpull:`2542`: Allow starting IPython as `python -m IPython`.
 * :ghpull:`2534`: Do not unescape backslashes in Windows (shellglob)
 * :ghpull:`2517`: Improved MathJax, bug fixes
 * :ghpull:`2511`: trigger default remote_profile_dir when profile_dir is set
 * :ghpull:`2491`: color is supported in ironpython
 * :ghpull:`2462`: Track which extensions are loaded
 * :ghpull:`2464`: Locate URLs in text output and convert them to hyperlinks.
 * :ghpull:`2490`: add ZMQInteractiveShell to IPEngineApp class list
 * :ghpull:`2498`: Don't catch tab press when something selected
 * :ghpull:`2527`: Run All Above and Run All Below
 * :ghpull:`2513`: add GitHub uploads to release script
 * :ghpull:`2529`: Windows aware tests for shellglob
 * :ghpull:`2478`: Fix doctest_run_option_parser for Windows
 * :ghpull:`2519`: clear In[ ] prompt numbers again
 * :ghpull:`2467`: Clickable links
 * :ghpull:`2500`: Add `encoding` attribute to `OutStream` class.
 * :ghpull:`2349`: ENH: added StackExchange-style MathJax filtering
 * :ghpull:`2503`: Fix traceback handling of SyntaxErrors without line numbers.
 * :ghpull:`2492`: add missing 'qtconsole' extras_require
 * :ghpull:`2480`: Add deprecation warnings for sympyprinting
 * :ghpull:`2334`: Make the ipengine monitor the ipcontroller heartbeat and die if the ipcontroller goes down
 * :ghpull:`2479`: use new _winapi instead of removed _subprocess
 * :ghpull:`2474`: fix bootstrap name conflicts
 * :ghpull:`2469`: Treat __init__.pyc same as __init__.py in module_list
 * :ghpull:`2165`: Add -g option to %run to glob expand arguments
 * :ghpull:`2468`: Tell git to ignore __pycache__ directories.
 * :ghpull:`2421`: Some notebook tweaks.
 * :ghpull:`2291`: Remove old plugin system
 * :ghpull:`2127`: Ability to build toolbar in JS 
 * :ghpull:`2445`: changes for ironpython
 * :ghpull:`2420`: Pass ipython_dir to __init__() method of TerminalInteractiveShell's superclass.
 * :ghpull:`2432`: Revert #1831, the `__file__` injection in safe_execfile / safe_execfile_ipy.
 * :ghpull:`2216`: Autochange highlight with cell magics
 * :ghpull:`1946`: Add image message handler in ZMQTerminalInteractiveShell
 * :ghpull:`2424`: skip find_cmd when setting up script magics
 * :ghpull:`2389`: Catch sqlite DatabaseErrors in more places when reading the history database
 * :ghpull:`2395`: Don't catch ImportError when trying to unpack module functions
 * :ghpull:`1868`: enable IPC transport for kernels
 * :ghpull:`2437`: don't let log cleanup prevent engine start
 * :ghpull:`2441`: `sys.maxsize` is the maximum length of a container.
 * :ghpull:`2442`: allow iptest to be interrupted
 * :ghpull:`2240`: fix message built for engine dying during task
 * :ghpull:`2369`: Block until kernel termination after sending a kill signal
 * :ghpull:`2439`: Py3k: Octal (0777 -> 0o777)
 * :ghpull:`2326`: Detachable pager in notebook.
 * :ghpull:`2377`: Fix installation of man pages in Python 3
 * :ghpull:`2407`: add IPython version to message headers
 * :ghpull:`2408`: Fix Issue #2366
 * :ghpull:`2405`: clarify TaskScheduler.hwm doc
 * :ghpull:`2399`: IndentationError display
 * :ghpull:`2400`: Add scroll_to_cell(cell_number) to the notebook
 * :ghpull:`2401`: unmock read-the-docs modules
 * :ghpull:`2311`: always perform requested trait assignments
 * :ghpull:`2393`: New option `n` to limit history search hits
 * :ghpull:`2386`: Adapt inline backend to changes in matplotlib
 * :ghpull:`2392`: Remove suspicious double quote
 * :ghpull:`2387`: Added -L library search path to cythonmagic cell magic
 * :ghpull:`2370`: qtconsole: Create a prompt newline by inserting a new block (w/o formatting)
 * :ghpull:`1715`: Fix for #1688, traceback-unicode issue
 * :ghpull:`2378`: use Singleton.instance() for embed() instead of manual global
 * :ghpull:`2373`: fix missing imports in core.interactiveshell
 * :ghpull:`2368`: remove notification widget leftover
 * :ghpull:`2327`: Parallel: Support get/set of nested objects in view (e.g. dv['a.b'])
 * :ghpull:`2362`: Clean up ProgressBar class in example notebook
 * :ghpull:`2346`: Extra xterm identification in set_term_title
 * :ghpull:`2352`: Notebook: Store the username in a cookie whose name is unique.
 * :ghpull:`2358`: add backport_pr to tools
 * :ghpull:`2365`: fix names of notebooks for download/save
 * :ghpull:`2364`: make clients use 'location' properly (fixes #2361)
 * :ghpull:`2354`: Refactor notebook templates to use Jinja2
 * :ghpull:`2339`: add bash completion example
 * :ghpull:`2345`: Remove references to 'version' no longer in argparse. Github issue #2343.
 * :ghpull:`2347`: adjust division error message checking to account for Python 3
 * :ghpull:`2305`: RemoteError._render_traceback_ calls self.render_traceback
 * :ghpull:`2338`: Normalize line endings for ipexec_validate, fix for #2315.
 * :ghpull:`2192`: Introduce Notification Area
 * :ghpull:`2329`: Better error messages for common magic commands.
 * :ghpull:`2337`: ENH: added StackExchange-style MathJax filtering
 * :ghpull:`2331`: update css for qtconsole in doc
 * :ghpull:`2317`: adding cluster_id to parallel.Client.__init__
 * :ghpull:`2130`: Add -l option to %R magic to allow passing in of local namespace
 * :ghpull:`2196`: Fix for bad command line argument to latex
 * :ghpull:`2300`: bug fix: was crashing when sqlite3 is not installed
 * :ghpull:`2184`: Expose store_history to execute_request messages.
 * :ghpull:`2308`: Add welcome_message option to enable_pylab
 * :ghpull:`2302`: Fix variable expansion on 'self'
 * :ghpull:`2299`: Remove code from prefilter that duplicates functionality in inputsplitter
 * :ghpull:`2295`: allow pip install from github repository directly
 * :ghpull:`2280`: fix SSH passwordless check for OpenSSH
 * :ghpull:`2290`: nbmanager
 * :ghpull:`2288`: s/assertEquals/assertEqual (again)
 * :ghpull:`2287`: Removed outdated dev docs.
 * :ghpull:`2218`: Use redirect for new notebooks
 * :ghpull:`2277`: nb: up/down arrow keys move to begin/end of line at top/bottom of cell
 * :ghpull:`2045`: Refactoring notebook managers and adding Azure backed storage.
 * :ghpull:`2271`: use display instead of send_figure in inline backend hooks
 * :ghpull:`2278`: allow disabling SQLite history
 * :ghpull:`2225`: Add "--annotate" option to `%%cython` magic.
 * :ghpull:`2246`: serialize individual args/kwargs rather than the containers
 * :ghpull:`2274`: CLN: Use name to id mapping of notebooks instead of searching.
 * :ghpull:`2270`: SSHLauncher tweaks
 * :ghpull:`2269`: add missing location when disambiguating controller IP
 * :ghpull:`2263`: Allow docs to build on http://readthedocs.org/
 * :ghpull:`2256`: Adding data publication example notebook.
 * :ghpull:`2255`: better flush iopub with AsyncResults
 * :ghpull:`2261`: Fix: longest_substr([]) -> ''
 * :ghpull:`2260`: fix mpr again
 * :ghpull:`2242`: Document globbing in `%history -g <pattern>`.
 * :ghpull:`2250`: fix html in notebook example
 * :ghpull:`2245`: Fix regression in embed() from pull-request #2096.
 * :ghpull:`2248`: track sha of master in test_pr messages
 * :ghpull:`2238`: Fast tests
 * :ghpull:`2211`: add data publication message
 * :ghpull:`2236`: minor test_pr tweaks
 * :ghpull:`2231`: Improve Image format validation and add html width,height
 * :ghpull:`2232`: Reapply monkeypatch to inspect.findsource()
 * :ghpull:`2235`: remove spurious print statement from setupbase.py
 * :ghpull:`2222`: adjust how canning deals with import strings
 * :ghpull:`2224`: fix css typo
 * :ghpull:`2223`: Custom tracebacks
 * :ghpull:`2214`: use KernelApp.exec_lines/files in IPEngineApp
 * :ghpull:`2199`: Wrap JS published by %%javascript in try/catch
 * :ghpull:`2212`: catch errors in markdown javascript
 * :ghpull:`2190`: Update code mirror 2.22 to 2.32
 * :ghpull:`2200`: documentation build broken in bb429da5b
 * :ghpull:`2194`: clean nan/inf in json_clean
 * :ghpull:`2198`: fix mpr for earlier git version
 * :ghpull:`2175`: add FileFindHandler for Notebook static files
 * :ghpull:`1990`: can func_defaults
 * :ghpull:`2069`: start improving serialization in parallel code
 * :ghpull:`2202`: Create a unique & temporary IPYTHONDIR for each testing group.
 * :ghpull:`2204`: Work around lack of os.kill in win32.
 * :ghpull:`2148`: win32 iptest: Use subprocess.Popen() instead of os.system().
 * :ghpull:`2179`: Pylab switch
 * :ghpull:`2124`: Add an API for registering magic aliases.
 * :ghpull:`2169`: ipdb: pdef, pdoc, pinfo magics all broken
 * :ghpull:`2174`: Ensure consistent indentation in `%magic`.
 * :ghpull:`1930`: add size-limiting to the DictDB backend
 * :ghpull:`2189`: Fix IPython.lib.latextools for Python 3
 * :ghpull:`2186`: removed references to h5py dependence in octave magic documentation
 * :ghpull:`2183`: Include the kernel object in the event object passed to kernel events
 * :ghpull:`2185`: added test for %store, fixed storemagic
 * :ghpull:`2138`: Use breqn.sty in dvipng backend if possible
 * :ghpull:`2182`: handle undefined param in notebooklist
 * :ghpull:`1831`: fix #1814 set __file__ when running .ipy files
 * :ghpull:`2051`: Add a metadata attribute to messages
 * :ghpull:`1471`: simplify IPython.parallel connections and enable Controller Resume
 * :ghpull:`2181`: add %%javascript, %%svg, and %%latex display magics
 * :ghpull:`2116`: different images in 00_notebook-tour
 * :ghpull:`2092`: %prun: Restore `stats.stream` after running `print_stream`.
 * :ghpull:`2159`: show message on notebook list if server is unreachable
 * :ghpull:`2176`: fix git mpr
 * :ghpull:`2152`: [qtconsole] Namespace not empty at startup
 * :ghpull:`2177`: remove numpy install from travis/tox scripts
 * :ghpull:`2090`: New keybinding for code cell execution + cell insertion
 * :ghpull:`2160`: Updating the parallel options pricing example
 * :ghpull:`2168`: expand line in cell magics
 * :ghpull:`2170`: Fix tab completion with IPython.embed_kernel().
 * :ghpull:`2096`: embed(): Default to the future compiler flags of the calling frame.
 * :ghpull:`2163`: fix 'remote_profie_dir' typo in SSH launchers
 * :ghpull:`2158`: [2to3 compat ] Tuple params in func defs
 * :ghpull:`2089`: Fix unittest DeprecationWarnings
 * :ghpull:`2142`: Refactor test_pr.py
 * :ghpull:`2140`: 2to3: Apply `has_key` fixer.
 * :ghpull:`2131`: Add option append (-a) to %save
 * :ghpull:`2117`: use explicit url in notebook example
-* :ghpull:`2133`: Tell git that *.py files contain Python code, for use in word-diffs.
+* :ghpull:`2133`: Tell git that ``*.py`` files contain Python code, for use in word-diffs.
 * :ghpull:`2134`: Apply 2to3 `next` fix.
 * :ghpull:`2126`: ipcluster broken with any batch launcher (PBS/LSF/SGE)
 * :ghpull:`2104`: Windows make file for Sphinx documentation
 * :ghpull:`2074`: Make BG color of inline plot configurable
 * :ghpull:`2123`: BUG: Look up the `_repr_pretty_` method on the class within the MRO rath...
 * :ghpull:`2100`: [in progress] python 2 and 3 compatibility without 2to3, second try
 * :ghpull:`2128`: open notebook copy in different tabs
 * :ghpull:`2073`: allows password and prefix for notebook
 * :ghpull:`1993`: Print View
 * :ghpull:`2086`: re-aliad %ed to %edit in qtconsole
 * :ghpull:`2110`: Fixes and improvements to the input splitter
 * :ghpull:`2101`: fix completer deletting newline
 * :ghpull:`2102`: Fix logging on interactive shell.
 * :ghpull:`2088`: Fix (some) Python 3.2 ResourceWarnings
 * :ghpull:`2064`: conform to pep 3110
 * :ghpull:`2076`: Skip notebook 'static' dir in test suite.
 * :ghpull:`2063`: Remove umlauts so py3 installations on LANG=C systems succeed.
 * :ghpull:`2068`: record sysinfo in sdist
 * :ghpull:`2067`: update tools/release_windows.py
 * :ghpull:`2065`: Fix parentheses typo
 * :ghpull:`2062`: Remove duplicates and auto-generated files from repo.
 * :ghpull:`2061`: use explicit tuple in exception
 * :ghpull:`2060`: change minus to \- or \(hy in manpages
 
 Issues (691):
 
 * :ghissue:`3940`: Install process documentation overhaul 
 * :ghissue:`3946`: The PDF option for `--post` should work with lowercase 
 * :ghissue:`3957`: Notebook help page broken in Firefox
 * :ghissue:`3894`: nbconvert test failure
 * :ghissue:`3887`: 1.0.0a1 shows blank screen in both firefox and chrome (windows 7)
 * :ghissue:`3703`: `nbconvert`: Output options -- names and documentataion
 * :ghissue:`3931`: Tab completion not working during debugging in the notebook
 * :ghissue:`3936`: Ipcluster plugin is not working with Ipython 1.0dev
 * :ghissue:`3941`: IPython Notebook kernel crash on Win7x64
 * :ghissue:`3926`: Ending Notebook renaming dialog with return creates new-line
 * :ghissue:`3932`: Incorrect empty docstring
 * :ghissue:`3928`: Passing variables to script from the workspace
 * :ghissue:`3774`: Notebooks with spaces in their names breaks nbconvert latex graphics
 * :ghissue:`3916`: tornado needs its own check
 * :ghissue:`3915`: Link to Parallel examples "found on GitHub" broken in docs
 * :ghissue:`3895`: Keyboard shortcuts box in notebook doesn't fit the screen
 * :ghissue:`3912`: IPython.utils fails automated test for RC1 1.0.0
 * :ghissue:`3636`: Code cell missing highlight on load
 * :ghissue:`3897`: under Windows, "ipython3 nbconvert "C:/blabla/first_try.ipynb" --to latex --post PDF" POST processing action fails because of a bad parameter
 * :ghissue:`3900`: python3 install syntax errors (OS X 10.8.4)
 * :ghissue:`3899`: nbconvert to latex fails on notebooks with spaces in file name
 * :ghissue:`3881`: Temporary Working Directory Test Fails
 * :ghissue:`2750`: A way to freeze code cells in the notebook
 * :ghissue:`3893`: Resize Local Image Files in Notebook doesn't work
 * :ghissue:`3823`: nbconvert on windows: tex and paths
 * :ghissue:`3885`: under Windows, "ipython3 nbconvert "C:/blabla/first_try.ipynb" --to latex" write "\" instead of "/" to reference file path in the .tex file
 * :ghissue:`3889`: test_qt fails due to assertion error 'qt4' != 'qt'
 * :ghissue:`3890`: double post, disregard this issue
 * :ghissue:`3689`: nbconvert, remaining tests
 * :ghissue:`3874`: Up/Down keys don't work to "Search previous command history" (besides Ctrl-p/Ctrl-n)
 * :ghissue:`3853`: CodeMirror locks up in the notebook
 * :ghissue:`3862`: can only connect to an ipcluster started with v1.0.0-dev (master branch) using an older ipython (v0.13.2), but cannot connect using ipython (v1.0.0-dev)
 * :ghissue:`3869`: custom css not working. 
 * :ghissue:`2960`: Keyboard shortcuts
 * :ghissue:`3795`: ipcontroller process goes to 100% CPU, ignores connection requests
 * :ghissue:`3553`: Ipython and pylab crashes in windows and canopy
 * :ghissue:`3837`: Cannot set custom mathjax url, crash notebook server.
 * :ghissue:`3808`: "Naming" releases ?
 * :ghissue:`2431`: TypeError: must be string without null bytes, not str
 * :ghissue:`3856`: `?` at end of comment causes line to execute
 * :ghissue:`3731`: nbconvert: add logging for the different steps of nbconvert
 * :ghissue:`3835`: Markdown cells do not render correctly when mathjax is disabled
 * :ghissue:`3843`: nbconvert to rst: leftover "In[ ]"
 * :ghissue:`3799`: nbconvert: Ability to specify name of output file
 * :ghissue:`3726`: Document when IPython.start_ipython() should be used versus IPython.embed()
 * :ghissue:`3778`: Add no more readonly view in what's new
 * :ghissue:`3754`: No Print View in Notebook in 1.0dev
 * :ghissue:`3798`: IPython 0.12.1 Crashes on autocompleting sqlalchemy.func.row_number properties
 * :ghissue:`3811`: Opening notebook directly from the command line with multi-directory support installed
 * :ghissue:`3775`: Annoying behavior when clicking on cell after execution (Ctrl+Enter)
 * :ghissue:`3809`: Possible to add some bpython features?
 * :ghissue:`3810`: Printing the contents of an image file messes up shell text
 * :ghissue:`3702`: `nbconvert`: Default help message should be that of --help
 * :ghissue:`3735`: Nbconvert 1.0.0a1 does not take into account the pdf extensions in graphs
 * :ghissue:`3719`: Bad strftime format, for windows, in nbconvert exporter 
 * :ghissue:`3786`: Zmq errors appearing with `Ctrl-C` in console/qtconsole
 * :ghissue:`3019`: disappearing scrollbar on tooltip in Chrome 24 on Ubuntu 12.04
 * :ghissue:`3785`: ipdb completely broken in Qt console
 * :ghissue:`3796`: Document the meaning of milestone/issues-tags for users.
 * :ghissue:`3788`: Do not auto show tooltip if docstring empty.
 * :ghissue:`1366`: [Web page] No link to front page from documentation
 * :ghissue:`3739`: nbconvert (to slideshow) misses some of the math in markdown cells
 * :ghissue:`3768`: increase and make timeout configurable in console completion.
 * :ghissue:`3724`: ipcluster only running on one cpu
 * :ghissue:`1592`: better message for unsupported nbformat
 * :ghissue:`2049`: Can not stop "ipython kernel" on windows
 * :ghissue:`3757`: Need direct entry point to given notebook 
 * :ghissue:`3745`: ImportError: cannot import name check_linecache_ipython
 * :ghissue:`3701`: `nbconvert`: Final output file should be in same directory as input file
 * :ghissue:`3738`: history -o works but history with -n produces identical results
 * :ghissue:`3740`: error when attempting to run 'make' in docs directory
 * :ghissue:`3737`: ipython nbconvert crashes with ValueError: Invalid format string.
 * :ghissue:`3730`: nbconvert: unhelpful error when pandoc isn't installed
 * :ghissue:`3718`: markdown cell cursor misaligned in notebook
 * :ghissue:`3710`: mutiple input fields for %debug in the notebook after resetting the kernel
 * :ghissue:`3713`: PyCharm has problems with IPython working inside PyPy created by virtualenv
 * :ghissue:`3712`: Code completion: Complete on dictionary keys
 * :ghissue:`3680`: --pylab and --matplotlib flag
 * :ghissue:`3698`: nbconvert: Unicode error with minus sign
 * :ghissue:`3693`: nbconvert does not process SVGs into PDFs
 * :ghissue:`3688`: nbconvert, figures not extracting with Python 3.x
 * :ghissue:`3542`: note new dependencies in docs / setup.py
 * :ghissue:`2556`: [pagedown] do not target_blank anchor link
 * :ghissue:`3684`: bad message when %pylab fails due import *other* than matplotlib
 * :ghissue:`3682`: ipython notebook pylab inline  import_all=False 
 * :ghissue:`3596`: MathjaxUtils race condition?
 * :ghissue:`1540`: Comment/uncomment selection in notebook
 * :ghissue:`2702`: frozen setup: permission denied for default ipython_dir
 * :ghissue:`3672`: allow_none on Number-like traits.
 * :ghissue:`2411`: add CONTRIBUTING.md
 * :ghissue:`481`: IPython terminal issue with Qt4Agg on XP SP3
 * :ghissue:`2664`: How to preserve user variables from import clashing?
 * :ghissue:`3436`: enable_pylab(import_all=False) still imports np
 * :ghissue:`2630`: lib.pylabtools.figsize : NameError when using Qt4Agg backend and %pylab magic. 
 * :ghissue:`3154`: Notebook: no event triggered when a Cell is created
 * :ghissue:`3579`: Nbconvert: SVG are not transformed to PDF anymore
 * :ghissue:`3604`: MathJax rendering problem in `%%latex` cell
 * :ghissue:`3668`: AttributeError: 'BlockingKernelClient' object has no attribute 'started_channels'
 * :ghissue:`3245`: SyntaxError: encoding declaration in Unicode string
 * :ghissue:`3639`: %pylab inline in IPYTHON notebook throws "RuntimeError: Cannot activate multiple GUI eventloops"
 * :ghissue:`3663`: frontend deprecation warnings
 * :ghissue:`3661`: run -m not behaving like python -m 
 * :ghissue:`3597`: re-do PR #3531 - allow markdown in Header cell
 * :ghissue:`3053`: Markdown in header cells is not rendered
 * :ghissue:`3655`: IPython finding its way into pasted strings. 
 * :ghissue:`3620`: uncaught errors in HTML output
 * :ghissue:`3646`: get_dict() error
 * :ghissue:`3004`: `%load_ext rmagic` fails when legacy ipy_user_conf.py is installed (in ipython 0.13.1 / OSX 10.8)
 * :ghissue:`3638`: setp() issue in ipython notebook with figure references
 * :ghissue:`3634`: nbconvert reveal to pdf conversion ignores styling, prints only a single page.
 * :ghissue:`1307`: Remove pyreadline workarounds, we now require pyreadline >= 1.7.1
 * :ghissue:`3316`: find_cmd test failure on Windows
 * :ghissue:`3494`: input() in notebook doesn't work in Python 3
 * :ghissue:`3427`: Deprecate `$` as mathjax delimiter
 * :ghissue:`3625`: Pager does not open from button
 * :ghissue:`3149`: Miscellaneous small nbconvert feedback
 * :ghissue:`3617`: 256 color escapes support
 * :ghissue:`3609`: %pylab inline blows up for single process ipython
 * :ghissue:`2934`: Publish the Interactive MPI Demo Notebook
 * :ghissue:`3614`: ansi escapes broken in master (ls --color)
 * :ghissue:`3610`: If you don't have markdown, python setup.py install says no pygments
 * :ghissue:`3547`: %run modules clobber each other
 * :ghissue:`3602`: import_item fails when one tries to use DottedObjectName instead of a string
 * :ghissue:`3563`: Duplicate tab completions in the notebook
 * :ghissue:`3599`: Problems trying to run IPython on python3 without installing...
 * :ghissue:`2937`: too long completion in notebook
 * :ghissue:`3479`: Write empty name for the notebooks
 * :ghissue:`3505`: nbconvert: Failure in specifying user filter
 * :ghissue:`1537`: think a bit about namespaces
 * :ghissue:`3124`: Long multiline strings in Notebook
 * :ghissue:`3464`: run -d message unclear
 * :ghissue:`2706`: IPython 0.13.1 ignoring $PYTHONSTARTUP
 * :ghissue:`3587`: LaTeX escaping bug in nbconvert when exporting to HTML
 * :ghissue:`3213`: Long running notebook died with a coredump
 * :ghissue:`3580`: Running ipython with pypy on windows
 * :ghissue:`3573`: custom.js not working
 * :ghissue:`3544`: IPython.lib test failure on Windows
 * :ghissue:`3352`: Install Sphinx extensions
 * :ghissue:`2971`: [notebook]user needs to press ctrl-c twice to stop notebook server should be put into terminal window
 * :ghissue:`2413`: ipython3 qtconsole fails to install: ipython 0.13 has no such extra feature 'qtconsole' 
 * :ghissue:`2618`: documentation is incorrect for install process
 * :ghissue:`2595`: mac 10.8 qtconsole export history
 * :ghissue:`2586`: cannot store aliases
 * :ghissue:`2714`: ipython qtconsole print unittest messages in console instead his own window. 
 * :ghissue:`2669`: cython magic failing to work with openmp.
 * :ghissue:`3256`: Vagrant pandas instance of iPython Notebook does not respect additional plotting arguments
 * :ghissue:`3010`: cython magic fail if cache dir is deleted while in session
 * :ghissue:`2044`: prune unused names from parallel.error
 * :ghissue:`1145`: Online help utility broken in QtConsole
 * :ghissue:`3439`: Markdown links no longer open in new window (with change from pagedown to marked)
 * :ghissue:`3476`:  _margv  for macros seems to be missing
 * :ghissue:`3499`: Add reveal.js library (version 2.4.0) inside IPython
 * :ghissue:`2771`: Wiki Migration to GitHub
 * :ghissue:`2887`: ipcontroller purging some engines during connect
 * :ghissue:`626`: Enable Resuming Controller
 * :ghissue:`2824`: Kernel restarting after message "Kernel XXXX failed to respond to heartbeat"
 * :ghissue:`2823`: %%cython magic gives ImportError: dlopen(long_file_name.so, 2): image not found
 * :ghissue:`2891`: In IPython for Python 3, system site-packages comes before user site-packages
 * :ghissue:`2928`: Add magic "watch" function (example)
 * :ghissue:`2931`: Problem rendering pandas dataframe in  Firefox for Windows
 * :ghissue:`2939`: [notebook] Figure legend not shown in inline backend if ouside the box of the axes
 * :ghissue:`2972`: [notebook] in Markdown mode, press Enter key at the end of <some http link>, the next line is indented unexpectly
 * :ghissue:`3069`: Instructions for installing IPython notebook on Windows
 * :ghissue:`3444`: Encoding problem: cannot use if user's name is not ascii?
 * :ghissue:`3335`: Reenable bracket matching
 * :ghissue:`3386`: Magic %paste not working in Python 3.3.2. TypeError: Type str doesn't support the buffer API
 * :ghissue:`3543`: Exception shutting down kernel from notebook dashboard (0.13.1)
 * :ghissue:`3549`: Codecell size changes with selection
 * :ghissue:`3445`: Adding newlines in %%latex cell
 * :ghissue:`3237`: [notebook] Can't close a notebook without errors
 * :ghissue:`2916`: colon invokes auto(un)indent in markdown cells
 * :ghissue:`2167`: Indent and dedent in htmlnotebook
 * :ghissue:`3545`: Notebook save button icon not clear
 * :ghissue:`3534`: nbconvert incompatible with Windows?
 * :ghissue:`3489`: Update example notebook that raw_input is allowed
 * :ghissue:`3396`: Notebook checkpoint time is displayed an hour out
 * :ghissue:`3261`: Empty revert to checkpoint menu if no checkpoint...
 * :ghissue:`2984`: "print" magic does not work in Python 3
 * :ghissue:`3524`: Issues with pyzmq and ipython on EPD update
 * :ghissue:`2434`: %store magic not auto-restoring
 * :ghissue:`2720`: base_url and static path
 * :ghissue:`2234`: Update various low resolution graphics for retina displays
 * :ghissue:`2842`: Remember passwords for pw-protected notebooks
 * :ghissue:`3244`: qtconsole: ValueError('close_fds is not supported on Windows platforms if you redirect stdin/stdout/stderr',)
 * :ghissue:`2215`: AsyncResult.wait(0) can hang waiting for the client to get results?
 * :ghissue:`2268`: provide mean to retrieve static data path
 * :ghissue:`1905`: Expose UI for worksheets within each notebook
 * :ghissue:`2380`: Qt inputhook prevents modal dialog boxes from displaying
 * :ghissue:`3185`: prettify on double //
 * :ghissue:`2821`: Test failure: IPython.parallel.tests.test_client.test_resubmit_header
 * :ghissue:`2475`: [Notebook] Line is deindented when typing eg a colon in markdown mode
 * :ghissue:`2470`: Do not destroy valid notebooks
 * :ghissue:`860`: Allow the standalone export of a notebook to HTML
 * :ghissue:`2652`: notebook with qt backend crashes at save image location popup
 * :ghissue:`1587`: Improve kernel restarting in the notebook
 * :ghissue:`2710`: Saving a plot in Mac OS X backend crashes IPython
 * :ghissue:`2596`: notebook "Last saved:" is misleading on file opening.
 * :ghissue:`2671`: TypeError :NoneType when executed "ipython qtconsole" in windows console
 * :ghissue:`2703`: Notebook scrolling breaks after pager is shown
 * :ghissue:`2803`: KernelManager and KernelClient should be two separate objects
 * :ghissue:`2693`: TerminalIPythonApp configuration fails without ipython_config.py
 * :ghissue:`2531`: IPython 0.13.1 python 2 32-bit installer includes 64-bit ipython*.exe launchers in the scripts folder
 * :ghissue:`2520`: Control-C kills port forwarding
 * :ghissue:`2279`: Setting `__file__` to None breaks Mayavi import
 * :ghissue:`2161`: When logged into notebook, long titles are incorrectly positioned
 * :ghissue:`1292`: Notebook, Print view should not be editable...
 * :ghissue:`1731`: test parallel launchers
 * :ghissue:`3227`: Improve documentation of ipcontroller and possible BUG
 * :ghissue:`2896`: IPController very unstable
 * :ghissue:`3517`: documentation build broken in head
 * :ghissue:`3522`: UnicodeDecodeError: 'ascii' codec can't decode byte on Pycharm on Windows
 * :ghissue:`3448`: Please include MathJax fonts with IPython Notebook
 * :ghissue:`3519`: IPython Parallel map mysteriously turns pandas Series into numpy ndarray
 * :ghissue:`3345`: IPython embedded shells ask if I want to exit, but I set confirm_exit = False
 * :ghissue:`3509`: IPython won't close without asking "Are you sure?" in Firefox 
 * :ghissue:`3471`: Notebook jinja2/markupsafe depedencies in manual
 * :ghissue:`3502`: Notebook broken in master
 * :ghissue:`3302`: autoreload does not work in ipython 0.13.x, python 3.3
 * :ghissue:`3475`: no warning when leaving/closing notebook on master without saved changes
 * :ghissue:`3490`: No obvious feedback when kernel crashes
 * :ghissue:`1912`: Move all autoreload tests to their own group
 * :ghissue:`2577`: sh.py and ipython for python 3.3
 * :ghissue:`3467`: %magic doesn't work
 * :ghissue:`3501`: Editing markdown cells that wrap has off-by-one errors in cursor positioning
 * :ghissue:`3492`: IPython for Python3
 * :ghissue:`3474`: unexpected keyword argument to remove_kernel
 * :ghissue:`2283`: TypeError when using '?' after a string in a %logstart session
 * :ghissue:`2787`: rmagic and pandas DataFrame
 * :ghissue:`2605`: Ellipsis literal triggers AttributeError
 * :ghissue:`1179`: Test unicode source in pinfo
 * :ghissue:`2055`: drop Python 3.1 support
 * :ghissue:`2293`: IPEP 2: Input transformations
 * :ghissue:`2790`: %paste and %cpaste not removing "..." lines
 * :ghissue:`3480`: Testing fails because iptest.py cannot be found
 * :ghissue:`2580`: will not run within PIL build directory
 * :ghissue:`2797`: RMagic, Dataframe Conversion Problem 
 * :ghissue:`2838`: Empty lines disappear from triple-quoted literals.
 * :ghissue:`3050`: Broken link on IPython.core.display page
 * :ghissue:`3473`: Config not passed down to subcommands
 * :ghissue:`3462`: Setting log_format in config file results in error (and no format changes)
 * :ghissue:`3311`: Notebook (occasionally) not working on windows (Sophos AV)
 * :ghissue:`3461`: Cursor positioning off by a character in auto-wrapped lines
 * :ghissue:`3454`:  _repr_html_ error
 * :ghissue:`3457`: Space in long Paragraph Markdown cell with Chinese or Japanese
 * :ghissue:`3447`: Run Cell Does not Work
 * :ghissue:`1373`: Last lines in long cells are hidden
 * :ghissue:`1504`: Revisit serialization in IPython.parallel
 * :ghissue:`1459`: Can't connect to 2 HTTPS notebook servers on the same host
 * :ghissue:`678`: Input prompt stripping broken with multiline data structures
 * :ghissue:`3001`: IPython.notebook.dirty flag is not set when a cell has unsaved changes
 * :ghissue:`3077`: Multiprocessing semantics in parallel.view.map
 * :ghissue:`3056`: links across notebooks
 * :ghissue:`3120`: Tornado 3.0
 * :ghissue:`3156`: update pretty to use Python 3 style for sets
 * :ghissue:`3197`: Can't escape multiple dollar signs in a markdown cell
 * :ghissue:`3309`: `Image()` signature/doc improvements
 * :ghissue:`3415`: Bug in IPython/external/path/__init__.py 
 * :ghissue:`3446`: Feature suggestion: Download matplotlib figure to client browser
 * :ghissue:`3295`: autoexported notebooks: only export explicitly marked cells
 * :ghissue:`3442`: Notebook: Summary table extracted from markdown headers
 * :ghissue:`3438`: Zooming notebook in chrome is broken in master 
 * :ghissue:`1378`: Implement autosave in notebook
 * :ghissue:`3437`: Highlighting matching parentheses
 * :ghissue:`3435`: module search segfault
 * :ghissue:`3424`: ipcluster --version
 * :ghissue:`3434`: 0.13.2 Ipython/genutils.py doesn't exist
 * :ghissue:`3426`: Feature request: Save by cell and not by line #: IPython %save magic
 * :ghissue:`3412`: Non Responsive Kernel: Running a Django development server from an IPython Notebook
 * :ghissue:`3408`: Save cell toolbar and slide type metadata in notebooks
 * :ghissue:`3246`: %paste regression with blank lines
 * :ghissue:`3404`: Weird error with $variable and grep in command line magic (!command)
 * :ghissue:`3405`: Key auto-completion in dictionaries?
 * :ghissue:`3259`: Codemirror linenumber css broken
 * :ghissue:`3397`: Vertical text misalignment in Markdown cells
 * :ghissue:`3391`: Revert #3358 once fix integrated into CM
 * :ghissue:`3360`: Error 500 while saving IPython notebook
 * :ghissue:`3375`: Frequent Safari/Webkit crashes
 * :ghissue:`3365`: zmq frontend
 * :ghissue:`2654`: User_expression issues
 * :ghissue:`3389`: Store history as plain text
 * :ghissue:`3388`: Ipython parallel: open TCP connection created for each result returned from engine
 * :ghissue:`3385`: setup.py failure on Python 3
 * :ghissue:`3376`: Setting `__module__` to None breaks pretty printing
 * :ghissue:`3374`: ipython qtconsole does not display the prompt on OSX
 * :ghissue:`3380`: simple call to kernel
 * :ghissue:`3379`: TaskRecord key 'started' not set
 * :ghissue:`3241`: notebook conection time out
 * :ghissue:`3334`: magic interpreter interpretes non magic commands?
 * :ghissue:`3326`: python3.3: Type error when launching SGE cluster in IPython notebook
 * :ghissue:`3349`: pip3 doesn't run 2to3?
 * :ghissue:`3347`: Longlist support in ipdb
 * :ghissue:`3343`: Make pip install / easy_install faster
 * :ghissue:`3337`: git submodules broke nightly PPA builds
 * :ghissue:`3206`: Copy/Paste Regression in QtConsole
 * :ghissue:`3329`: Buggy linewrap in Mac OSX Terminal (Mountain Lion)
 * :ghissue:`3327`: Qt version check broken
 * :ghissue:`3303`: parallel tasks never finish under heavy load
 * :ghissue:`1381`: '\\' for equation continuations require an extra '\' in markdown cells
 * :ghissue:`3314`: Error launching iPython
 * :ghissue:`3306`: Test failure when running on a Vagrant VM
 * :ghissue:`3280`: IPython.utils.process.getoutput returns stderr
 * :ghissue:`3299`: variables named _ or __ exhibit incorrect behavior
 * :ghissue:`3196`: add an "x" or similar to htmlnotebook pager
 * :ghissue:`3293`: Several 404 errors for js files Firefox
 * :ghissue:`3292`: syntax highlighting in chrome on OSX 10.8.3
 * :ghissue:`3288`: Latest dev version hangs on page load
 * :ghissue:`3283`: ipython dev retains directory information after directory change
 * :ghissue:`3279`: custom.css is not overridden in the dev IPython (1.0)
 * :ghissue:`2727`: %run -m doesn't support relative imports
 * :ghissue:`3268`: GFM triple backquote and unknown language
 * :ghissue:`3273`: Suppressing all plot related outputs
 * :ghissue:`3272`: Backspace while completing load previous page
 * :ghissue:`3260`: Js error in savewidget
 * :ghissue:`3247`: scrollbar in notebook when not needed?
 * :ghissue:`3243`: notebook: option to view json source from browser
 * :ghissue:`3265`: 404 errors when running IPython 1.0dev 
 * :ghissue:`3257`: setup.py not finding submodules
 * :ghissue:`3253`: Incorrect Qt and PySide version comparison
 * :ghissue:`3248`: Cell magics broken in Qt console
 * :ghissue:`3012`: Problems with the less based style.min.css
 * :ghissue:`2390`: Image width/height don't work in embedded images
 * :ghissue:`3236`: cannot set TerminalIPythonApp.log_format
 * :ghissue:`3214`: notebook kernel dies if started with invalid parameter
 * :ghissue:`2980`: Remove HTMLCell ?
 * :ghissue:`3128`: qtconsole hangs on importing pylab (using X forwarding)
 * :ghissue:`3198`: Hitting recursive depth causing all notebook pages to hang
 * :ghissue:`3218`: race conditions in profile directory creation
 * :ghissue:`3177`: OverflowError execption in handlers.py
 * :ghissue:`2563`: core.profiledir.check_startup_dir() doesn't work inside py2exe'd installation
 * :ghissue:`3207`: [Feature] folders for ipython notebook dashboard
 * :ghissue:`3178`: cell magics do not work with empty lines after #2447
 * :ghissue:`3204`: Default plot() colors unsuitable for red-green colorblind users
-* :ghissue:`1789`: :\n/*foo turns into :\n*(foo) in triple-quoted strings.
+* :ghissue:`1789`: ``:\n/*foo`` turns into ``:\n*(foo)`` in triple-quoted strings.
 * :ghissue:`3202`: File cell magic fails with blank lines
 * :ghissue:`3199`: %%cython -a stopped working?
 * :ghissue:`2688`: obsolete imports in import autocompletion
 * :ghissue:`3192`: Python2, Unhandled exception, __builtin__.True = False
 * :ghissue:`3179`: script magic error message loop
 * :ghissue:`3009`: use XDG_CACHE_HOME for cython objects
 * :ghissue:`3059`: Bugs in 00_notebook_tour example.
 * :ghissue:`3104`: Integrate a javascript file manager into the notebook front end
 * :ghissue:`3176`: Particular equation not rendering  (notebook)
 * :ghissue:`1133`: [notebook] readonly and upload files/UI
 * :ghissue:`2975`: [notebook] python file and cell toolbar
 * :ghissue:`3017`: SciPy.weave broken in IPython notebook/ qtconsole 
 * :ghissue:`3161`: paste macro not reading spaces correctly
 * :ghissue:`2835`: %paste not working on WinXpSP3/ipython-0.13.1.py2-win32-PROPER.exe/python27
 * :ghissue:`2628`: Make transformers work for lines following decorators
 * :ghissue:`2612`: Multiline String containing ":\n?foo\n" confuses interpreter to replace ?foo with get_ipython().magic(u'pinfo foo')
 * :ghissue:`2539`: Request: Enable cell magics inside of .ipy scripts
 * :ghissue:`2507`: Multiline string does not work (includes `...`) with doctest type input in IPython notebook
 * :ghissue:`2164`: Request: Line breaks in line magic command
 * :ghissue:`3106`: poor parallel performance with many jobs
 * :ghissue:`2438`: print inside multiprocessing crashes Ipython kernel
 * :ghissue:`3155`: Bad md5 hash for package 0.13.2
 * :ghissue:`3045`: [Notebook] Ipython Kernel does not start if disconnected from internet(/network?)
 * :ghissue:`3146`: Using celery in python 3.3
 * :ghissue:`3145`: The notebook viewer is down
 * :ghissue:`2385`: grep --color not working well with notebook
 * :ghissue:`3131`: Quickly install from source in a clean virtualenv?
 * :ghissue:`3139`: Rolling log for ipython
 * :ghissue:`3127`: notebook with pylab=inline appears to call figure.draw twice
 * :ghissue:`3129`: Walking up and down the call stack
 * :ghissue:`3123`: Notebook crashed if unplugged ethernet cable
 * :ghissue:`3121`: NB should use normalize.css? was #3049
 * :ghissue:`3087`: Disable spellchecking in notebook
 * :ghissue:`3084`: ipython pyqt 4.10 incompatibilty, QTextBlockUserData
 * :ghissue:`3113`: Fails to install under Jython 2.7 beta
 * :ghissue:`3110`: Render of h4 headers is not correct in notebook (error in renderedhtml.css)
 * :ghissue:`3109`: BUG: read_csv: dtype={'id' : np.str}: Datatype not understood
 * :ghissue:`3107`: Autocompletion of object attributes in arrays
 * :ghissue:`3103`: Reset locale setting in qtconsole
 * :ghissue:`3090`: python3.3 Entry Point not found
 * :ghissue:`3081`: UnicodeDecodeError when using Image(data="some.jpeg")
 * :ghissue:`2834`: url regexp only finds one link
 * :ghissue:`3091`: qtconsole breaks doctest.testmod() in Python 3.3
 * :ghissue:`3074`: SIGUSR1 not available on Windows
 * :ghissue:`2996`: registration::purging stalled registration high occurrence in small clusters 
 * :ghissue:`3065`: diff-ability of notebooks
 * :ghissue:`3067`: Crash with pygit2
 * :ghissue:`3061`: Bug handling Ellipsis
 * :ghissue:`3049`: NB css inconsistent behavior between ff and webkit
 * :ghissue:`3039`: unicode errors when opening a new notebook
 * :ghissue:`3048`: Installning ipython qtConsole should be easyer att Windows
 * :ghissue:`3042`: Profile creation fails on 0.13.2 branch
 * :ghissue:`3035`: docstring typo/inconsistency: mention of an xml notebook format?
 * :ghissue:`3031`: HDF5 library segfault (possibly due to mismatching headers?)
 * :ghissue:`2991`: In notebook importing sympy closes ipython kernel
 * :ghissue:`3027`: f.__globals__ causes an error in Python 3.3
 * :ghissue:`3020`: Failing test test_interactiveshell.TestAstTransform on Windows
 * :ghissue:`3023`: alt text for "click to expand output" has typo in alt text
 * :ghissue:`2963`: %history to print all input history of a  previous session when line range is omitted
 * :ghissue:`3018`: IPython installed within virtualenv. WARNING "Please install IPython inside the virtualtenv"
 * :ghissue:`2484`: Completion in Emacs *Python* buffer causes prompt to be increased.
 * :ghissue:`3014`: Ctrl-C finishes notebook immediately
 * :ghissue:`3007`: cython_pyximport reload broken in python3
 * :ghissue:`2955`: Incompatible Qt imports when running inprocess_qtconsole
 * :ghissue:`3006`: [IPython 0.13.1] The check of PyQt version is wrong
 * :ghissue:`3005`: Renaming a notebook to an existing notebook name overwrites the other file
 * :ghissue:`2940`: Abort trap in IPython Notebook after installing matplotlib
 * :ghissue:`3000`: issue #3000
 * :ghissue:`2995`: ipython_directive.py fails on multiline when prompt number < 100
 * :ghissue:`2993`: File magic (%%file) does not work with paths beginning with tilde (e.g., ~/anaconda/stuff.txt)
 * :ghissue:`2992`: Cell-based input for console and qt frontends?
 * :ghissue:`2425`: Liaise with Spyder devs to integrate newer IPython
 * :ghissue:`2986`: requesting help in a loop can damage a notebook
 * :ghissue:`2978`: v1.0-dev build errors on Arch with Python 3.
 * :ghissue:`2557`: [refactor] Insert_cell_at_index()
 * :ghissue:`2969`: ipython command does not work in terminal
 * :ghissue:`2762`: OSX wxPython (osx_cocoa, 64bit) command "%gui wx" blocks the interpreter
 * :ghissue:`2956`: Silent importing of submodules differs from standard Python3.2 interpreter's behavior
 * :ghissue:`2943`: Up arrow key history search gets stuck in QTConsole
 * :ghissue:`2953`: using 'nonlocal' declaration in global scope causes ipython3 crash
 * :ghissue:`2952`: qtconsole ignores exec_lines
 * :ghissue:`2949`: ipython crashes due to atexit()
 * :ghissue:`2947`: From rmagic to  an R console
 * :ghissue:`2938`: docstring pane not showing in notebook
 * :ghissue:`2936`: Tornado assumes invalid signature for parse_qs on Python 3.1
 * :ghissue:`2935`: unable to find python after easy_install / pip install
 * :ghissue:`2920`: Add undo-cell deletion menu
 * :ghissue:`2914`: BUG:saving a modified .py file after loading a module kills the kernel
 * :ghissue:`2925`: BUG: kernel dies if user sets sys.stderr or sys.stdout to a file object
 * :ghissue:`2909`: LaTeX sometimes fails to render in markdown cells with some curly bracket + underscore combinations
 * :ghissue:`2898`: Skip ipc tests on Windows
 * :ghissue:`2902`: ActiveState attempt to build ipython 0.12.1 for python 3.2.2 for Mac OS failed
 * :ghissue:`2899`: Test failure in IPython.core.tests.test_magic.test_time
 * :ghissue:`2890`: Test failure when fabric not installed
 * :ghissue:`2892`: IPython tab completion bug for paths
 * :ghissue:`1340`: Allow input cells to be collapsed
 * :ghissue:`2881`: ? command in notebook does not show help in Safari
 * :ghissue:`2751`: %%timeit should use minutes to format running time in long running cells
 * :ghissue:`2879`: When importing a module with a wrong name, ipython crashes
 * :ghissue:`2862`: %%timeit should warn of empty contents
 * :ghissue:`2485`: History navigation breaks in qtconsole
 * :ghissue:`2785`: gevent input hook
 * :ghissue:`2843`: Sliently running code in clipboard (with paste, cpaste and variants)
 * :ghissue:`2784`: %run -t -N<N> error
 * :ghissue:`2732`: Test failure with FileLinks class on Windows
 * :ghissue:`2860`: ipython help notebook -> KeyError: 'KernelManager'
 * :ghissue:`2858`: Where is the installed `ipython` script?
 * :ghissue:`2856`: Edit code entered from ipython in external editor
 * :ghissue:`2722`: IPC transport option not taking effect ?
 * :ghissue:`2473`: Better error messages in ipengine/ipcontroller
 * :ghissue:`2836`: Cannot send builtin module definitions to IP engines
 * :ghissue:`2833`: Any reason not to use super() ? 
 * :ghissue:`2781`: Cannot interrupt infinite loops in the notebook
 * :ghissue:`2150`: clippath_demo.py in matplotlib example does not work with inline backend
 * :ghissue:`2634`: Numbered list in notebook markdown cell renders with Roman numerals instead of numbers
 * :ghissue:`2230`: IPython crashing during startup with "AttributeError: 'NoneType' object has no attribute 'rstrip'"
 * :ghissue:`2483`: nbviewer bug? with multi-file gists
 * :ghissue:`2466`: mistyping `ed -p` breaks `ed -p`
 * :ghissue:`2477`: Glob expansion tests fail on Windows
 * :ghissue:`2622`: doc issue: notebooks that ship with Ipython .13 are written for python 2.x
 * :ghissue:`2626`: Add "Cell -> Run All Keep Going" for notebooks
 * :ghissue:`1223`: Show last modification date of each notebook
 * :ghissue:`2621`: user request: put link to example notebooks in Dashboard
 * :ghissue:`2564`: grid blanks plots in ipython pylab inline mode (interactive)
 * :ghissue:`2532`: Django shell (IPython) gives NameError on dict comprehensions
 * :ghissue:`2188`: ipython crashes on ctrl-c
 * :ghissue:`2391`: Request: nbformat API to load/save without changing version
 * :ghissue:`2355`: Restart kernel message even though kernel is perfectly alive
 * :ghissue:`2306`: Garbled input text after reverse search on Mac OS X
 * :ghissue:`2297`: ipdb with separate kernel/client pushing stdout to kernel process only
 * :ghissue:`2180`: Have [kernel busy] overridden only by [kernel idle]
 * :ghissue:`1188`: Pylab with OSX backend keyboard focus issue and hang
 * :ghissue:`2107`: test_octavemagic.py[everything] fails 
 * :ghissue:`1212`: Better understand/document browser compatibility
 * :ghissue:`1585`: Refactor notebook templates to use Jinja2 and make each page a separate directory
 * :ghissue:`1443`: xticks scaling factor partially obscured with qtconsole and inline plotting 
 * :ghissue:`1209`: can't make %result work as in doc.
 * :ghissue:`1200`: IPython 0.12 Windows install fails on Vista
 * :ghissue:`1127`: Interactive test scripts for Qt/nb issues
 * :ghissue:`959`: Matplotlib figures hide
 * :ghissue:`2071`: win32 installer issue on Windows XP
 * :ghissue:`2610`: ZMQInteractiveShell.colors being ignored
 * :ghissue:`2505`: Markdown Cell incorrectly highlighting after "<"
 * :ghissue:`165`: Installer fails to create Start Menu entries on Windows
 * :ghissue:`2356`: failing traceback in terminal ipython for first exception
 * :ghissue:`2145`: Have dashboad show when server disconect
 * :ghissue:`2098`: Do not crash on kernel shutdow if json file is missing
 * :ghissue:`2813`: Offline MathJax is broken on 0.14dev
 * :ghissue:`2807`: Test failure: IPython.parallel.tests.test_client.TestClient.test_purge_everything
 * :ghissue:`2486`: Readline's history search in ipython console does not clear properly after cancellation with Ctrl+C
 * :ghissue:`2709`: Cython -la doesn't work
 * :ghissue:`2767`: What is IPython.utils.upgradedir ?
 * :ghissue:`2210`: Placing matplotlib legend outside axis bounds causes inline display to clip it
 * :ghissue:`2553`: IPython Notebooks not robust against client failures
 * :ghissue:`2536`: ImageDraw in Ipython notebook not drawing lines
 * :ghissue:`2264`: Feature request: Versioning messaging protocol
 * :ghissue:`2589`: Creation of ~300+ MPI-spawned engines causes instability in ipcluster
 * :ghissue:`2672`: notebook: inline option without pylab
 * :ghissue:`2673`: Indefinite Articles & Traitlets
 * :ghissue:`2705`: Notebook crashes Safari with select and drag
 * :ghissue:`2721`: dreload kills ipython when it hits zmq
 * :ghissue:`2806`: ipython.parallel doesn't discover globals under Python 3.3
 * :ghissue:`2794`: _exit_code behaves differently in terminal vs ZMQ frontends
 * :ghissue:`2793`: IPython.parallel issue with pushing pandas TimeSeries
 * :ghissue:`1085`: In process kernel for Qt frontend
 * :ghissue:`2760`: IndexError: list index out of range with Python 3.2
 * :ghissue:`2780`: Save and load notebooks from github
 * :ghissue:`2772`: AttributeError: 'Client' object has no attribute 'kill'
 * :ghissue:`2754`: Fail to send class definitions from interactive session to engines namespaces
 * :ghissue:`2764`: TypeError while using 'cd'
 * :ghissue:`2765`: name '__file__' is not defined
 * :ghissue:`2540`: Wrap tooltip if line exceeds threshold?
 * :ghissue:`2394`: Startup error on ipython qtconsole (version 0.13 and 0.14-dev
 * :ghissue:`2440`: IPEP 4: Python 3 Compatibility
 * :ghissue:`1814`: __file__ is not defined when file end with .ipy
 * :ghissue:`2759`: R magic extension interferes with tab completion
 * :ghissue:`2615`: Small change needed to rmagic extension.
 * :ghissue:`2748`: collapse parts of a html notebook
 * :ghissue:`1661`: %paste still bugs about IndentationError and says to use %paste
 * :ghissue:`2742`: Octavemagic fails to deliver inline images in IPython (on Windows)
 * :ghissue:`2739`: wiki.ipython.org contaminated with prescription drug spam
 * :ghissue:`2588`: Link error while executing code from cython example notebook
 * :ghissue:`2550`: Rpush magic doesn't find local variables and doesn't support comma separated lists of variables
 * :ghissue:`2675`: Markdown/html blockquote need css.
 * :ghissue:`2419`: TerminalInteractiveShell.__init__() ignores value of ipython_dir argument
 * :ghissue:`1523`: Better LaTeX printing in the qtconsole with the sympy profile
 * :ghissue:`2719`: ipython fails with `pkg_resources.DistributionNotFound: ipython==0.13`
 * :ghissue:`2715`: url crashes nbviewer.ipython.org
 * :ghissue:`2555`: "import" module completion on MacOSX
 * :ghissue:`2707`: Problem installing the new version of IPython in Windows
 * :ghissue:`2696`: SymPy magic bug in IPython Notebook
 * :ghissue:`2684`: pretty print broken for types created with PyType_FromSpec
 * :ghissue:`2533`: rmagic breaks on Windows
 * :ghissue:`2661`: Qtconsole tooltip is too wide when the function has many arguments
 * :ghissue:`2679`: ipython3 qtconsole via Homebrew on Mac OS X 10.8 - pyqt/pyside import error
 * :ghissue:`2646`: pylab_not_importable
 * :ghissue:`2587`: cython magic pops 2 CLI windows upon execution on Windows
 * :ghissue:`2660`: Certain arguments (-h, --help, --version) never passed to scripts run with ipython
 * :ghissue:`2665`: Missing docs for rmagic and some other extensions
 * :ghissue:`2611`: Travis wants to drop 3.1 support
 * :ghissue:`2658`: Incorrect parsing of raw multiline strings
 * :ghissue:`2655`: Test fails if `from __future__ import print_function` in .pythonrc.py
 * :ghissue:`2651`: nonlocal with no existing variable produces too many errors
 * :ghissue:`2645`: python3 is a pain (minor unicode bug)
 * :ghissue:`2637`: %paste in Python 3 on Mac doesn't work
 * :ghissue:`2624`: Error on launching IPython on Win 7 and Python 2.7.3
 * :ghissue:`2608`: disk IO activity on cursor press
 * :ghissue:`1275`: Markdown parses LaTeX math symbols as its formatting syntax in notebook
 * :ghissue:`2613`: display(Math(...)) doesn't render \tau correctly
 * :ghissue:`925`: Tab-completion in Qt console needn't use pager
 * :ghissue:`2607`: %load_ext sympy.interactive.ipythonprinting  dammaging output
 * :ghissue:`2593`: Toolbar button to open qtconsole from notebook
 * :ghissue:`2602`: IPython html documentation for downloading
 * :ghissue:`2598`: ipython notebook --pylab=inline replaces built-in any()
 * :ghissue:`2244`: small issue: wrong printout
 * :ghissue:`2590`: add easier way to execute scripts in the current directory
 * :ghissue:`2581`: %hist does not work when InteractiveShell.cache_size = 0
 * :ghissue:`2584`: No file COPYING
 * :ghissue:`2578`: AttributeError: 'module' object has no attribute 'TestCase'
 * :ghissue:`2576`: One of my notebooks won't load any more -- is there a maximum notebook size?
 * :ghissue:`2560`: Notebook output is invisible when printing strings with \r\r\n line endings
 * :ghissue:`2566`: if pyside partially present ipython qtconsole fails to load even if pyqt4 present
 * :ghissue:`1308`: ipython qtconsole  --ssh=server --existing ... hangs
 * :ghissue:`1679`: List command doesn't work in ipdb debugger the first time
 * :ghissue:`2545`: pypi win32 installer creates 64bit executibles
-* :ghissue:`2080`: Event loop issues with IPython 0.12 and PyQt4 (QDialog.exec_ and more)
+* :ghissue:`2080`: Event loop issues with IPython 0.12 and PyQt4 (``QDialog.exec_`` and more)
 * :ghissue:`2541`: Allow `python -m IPython`
 * :ghissue:`2508`: subplots_adjust() does not work correctly in ipython notebook
 * :ghissue:`2289`: Incorrect mathjax rendering of certain arrays of equations
 * :ghissue:`2487`: Selecting and indenting
 * :ghissue:`2521`: more fine-grained 'run' controls, such as 'run from here' and 'run until here'
 * :ghissue:`2535`: Funny bounding box when plot with text
 * :ghissue:`2523`: History not working
 * :ghissue:`2514`: Issue with zooming in qtconsole
 * :ghissue:`2220`: No sys.stdout.encoding in kernel based IPython
 * :ghissue:`2512`: ERROR: Internal Python error in the inspect module.
 * :ghissue:`2496`: Function passwd does not work in QtConsole
 * :ghissue:`1453`: make engines reconnect/die when controller was restarted
 * :ghissue:`2481`: ipython notebook -- clicking in a code cell's output moves the screen to the top of the code cell
 * :ghissue:`2488`: Undesired plot outputs in Notebook inline mode
 * :ghissue:`2482`: ipython notebook -- download may not get the latest notebook
 * :ghissue:`2471`: _subprocess module removed in Python 3.3
 * :ghissue:`2374`: Issues with man pages
 * :ghissue:`2316`: parallel.Client.__init__ should take cluster_id kwarg
 * :ghissue:`2457`: Can a R library wrapper be created with Rmagic?
 * :ghissue:`1575`: Fallback frontend for console when connecting pylab=inlnie -enabled kernel?
 * :ghissue:`2097`: Do not crash if history db is corrupted
 * :ghissue:`2435`: ipengines fail if clean_logs enabled
 * :ghissue:`2429`: Using warnings.warn() results in TypeError
 * :ghissue:`2422`: Multiprocessing in ipython notebook kernel crash
 * :ghissue:`2426`: ipython crashes with the following message. I do not what went wrong. Can you help me identify the problem?
 * :ghissue:`2423`: Docs typo?
 * :ghissue:`2257`: pip install -e fails
 * :ghissue:`2418`: rmagic can't run R's read.csv on data files with NA data
 * :ghissue:`2417`: HTML notebook: Backspace sometimes deletes multiple characters
 * :ghissue:`2275`: notebook: "Down_Arrow" on last line of cell should move to end of line
 * :ghissue:`2414`: 0.13.1 does not work with current EPD 7.3-2
 * :ghissue:`2409`: there is a redundant None
 * :ghissue:`2410`: Use /usr/bin/python3 instead of /usr/bin/python
 * :ghissue:`2366`: Notebook Dashboard --notebook-dir and fullpath
 * :ghissue:`2406`: Inability to get docstring in debugger
 * :ghissue:`2398`: Show line number for IndentationErrors
 * :ghissue:`2314`: HTML lists seem to interfere with the QtConsole display
 * :ghissue:`1688`: unicode exception when using %run with failing script
 * :ghissue:`1884`: IPython.embed changes color on error
 * :ghissue:`2381`: %time doesn't work for multiline statements
 * :ghissue:`1435`: Add size keywords in Image class
 * :ghissue:`2372`: interactiveshell.py misses urllib and io_open imports
 * :ghissue:`2371`: iPython not working
 * :ghissue:`2367`: Tab expansion moves to next cell in notebook
 * :ghissue:`2359`: nbviever alters the order of print and display() output
 * :ghissue:`2227`: print name for IPython Notebooks has become uninformative
 * :ghissue:`2361`: client doesn't use connection file's 'location' in disambiguating 'interface'
 * :ghissue:`2357`: failing traceback in terminal ipython for first exception
 * :ghissue:`2343`: Installing in a python 3.3b2 or python 3.3rc1 virtual environment.
 * :ghissue:`2315`: Failure in test: "Test we're not loading modules on startup that we shouldn't." 
 * :ghissue:`2351`: Multiple Notebook Apps: cookies not port specific, clash with each other
 * :ghissue:`2350`: running unittest from qtconsole prints output to terminal
 * :ghissue:`2303`:  remote tracebacks broken since 952d0d6 (PR #2223)
 * :ghissue:`2330`: qtconsole does not hightlight tab-completion suggestion with custom stylesheet
 * :ghissue:`2325`: Parsing Tex formula fails in Notebook
 * :ghissue:`2324`: Parsing Tex formula fails
 * :ghissue:`1474`: Add argument to `run -n` for custom namespace
 * :ghissue:`2318`: C-m n/p don't work in Markdown cells in the notebook
 * :ghissue:`2309`: time.time() in ipython notebook producing impossible results
 * :ghissue:`2307`: schedule tasks on newly arrived engines
 * :ghissue:`2313`: Allow Notebook HTML/JS to send messages to Python code
 * :ghissue:`2304`: ipengine throws KeyError: url
 * :ghissue:`1878`: shell access using ! will not fill class or function scope vars
 * :ghissue:`2253`: %paste does not retrieve clipboard contents under screen/tmux on OS X
 * :ghissue:`1510`: Add-on (or Monkey-patch) infrastructure for HTML notebook
 * :ghissue:`2273`: triple quote and %s at beginning of line with %paste
 * :ghissue:`2243`: Regression in .embed()
 * :ghissue:`2266`: SSH passwordless check with OpenSSH checks for the wrong thing
 * :ghissue:`2217`: Change NewNotebook handler to use 30x redirect
 * :ghissue:`2276`: config option for disabling history store
 * :ghissue:`2239`: can't use parallel.Reference in view.map
 * :ghissue:`2272`: Sympy piecewise messed up rendering
 * :ghissue:`2252`: %paste throws an exception with empty clipboard
 * :ghissue:`2259`: git-mpr is currently broken
 * :ghissue:`2247`: Variable expansion in shell commands should work in substrings
 * :ghissue:`2026`: Run 'fast' tests only
 * :ghissue:`2241`: read a list of notebooks on server and bring into browser only notebook
 * :ghissue:`2237`: please put python and text editor in the web only ipython
 * :ghissue:`2053`: Improvements to the IPython.display.Image object
 * :ghissue:`1456`: ERROR: Internal Python error in the inspect module.
 * :ghissue:`2221`: Avoid importing from IPython.parallel in core
 * :ghissue:`2213`: Can't trigger startup code in Engines
 * :ghissue:`1464`: Strange behavior for backspace with lines ending with more than 4 spaces in notebook 
 * :ghissue:`2187`: NaN in object_info_reply JSON causes parse error
 * :ghissue:`214`: system command requiring administrative privileges  
 * :ghissue:`2195`: Unknown option `no-edit` in git-mpr
 * :ghissue:`2201`: Add documentation build to tools/test_pr.py
 * :ghissue:`2205`: Command-line option for default Notebook output collapsing behavior
 * :ghissue:`1927`: toggle between inline and floating figures
 * :ghissue:`2171`: Can't start StarCluster after upgrading to IPython 0.13
 * :ghissue:`2173`: oct2py v >= 0.3.1 doesn't need h5py anymore
 * :ghissue:`2099`: storemagic needs to use self.shell
 * :ghissue:`2166`: DirectView map_sync() with Lambdas Using Generators
 * :ghissue:`2091`: Unable to use print_stats after %prun -r in notebook
 * :ghissue:`2132`: Add fail-over for pastebin
 * :ghissue:`2156`: Make it possible to install ipython without nasty gui dependencies
 * :ghissue:`2154`: Scrolled long output should be off in print view by default
 * :ghissue:`2162`: Tab completion does not work with IPython.embed_kernel()
 * :ghissue:`2157`: iPython 0.13 / github-master cannot create logfile from scratch
 * :ghissue:`2151`: missing newline when a magic is called from the qtconsole menu
 * :ghissue:`2139`: 00_notebook_tour Image example broken on master
 * :ghissue:`2143`: Add a %%cython_annotate magic
 * :ghissue:`2135`: Running IPython from terminal
 * :ghissue:`2093`: Makefile for building Sphinx documentation on Windows 
 * :ghissue:`2122`: Bug in pretty printing
 * :ghissue:`2120`: Notebook "Make a Copy..." keeps opening duplicates in the same tab
 * :ghissue:`1997`: password cannot be used with url prefix
 * :ghissue:`2129`: help/doc displayed multiple times if requested in loop
 * :ghissue:`2121`: ipdb does not support input history in qtconsole
 * :ghissue:`2114`: %logstart doesn't log
 * :ghissue:`2085`: %ed magic fails in qtconsole
 * :ghissue:`2119`: iPython fails to run on MacOS Lion 
 * :ghissue:`2052`: %pylab inline magic does not work on windows
 * :ghissue:`2111`: Ipython won't start on W7
 * :ghissue:`2112`: Strange internal traceback
 * :ghissue:`2108`: Backslash (\) at the end of the line behavior different from default Python
 * :ghissue:`1425`: Ampersands can't be typed sometimes in notebook cells
 * :ghissue:`1513`: Add expand/collapse support for long output elements like stdout and tracebacks
 * :ghissue:`2087`: error when starting ipython
 * :ghissue:`2103`: Ability to run notebook file from commandline
 * :ghissue:`2082`: Qt Console output spacing
 * :ghissue:`2083`: Test failures with Python 3.2 and PYTHONWARNINGS="d"
 * :ghissue:`2094`: about inline
 * :ghissue:`2077`: Starting IPython3 on the terminal
 * :ghissue:`1760`: easy_install ipython fails on py3.2-win32
 * :ghissue:`2075`: Local Mathjax install causes iptest3 error under python3
 * :ghissue:`2057`: setup fails for python3 with LANG=C
 * :ghissue:`2070`: shebang on Windows
 * :ghissue:`2054`: sys_info missing git hash in sdists
 * :ghissue:`2059`: duplicate and modified files in documentation
 * :ghissue:`2056`: except-shadows-builtin osm.py:687
 * :ghissue:`2058`: hyphen-used-as-minus-sign in manpages