Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

1 files changed, 568 insertions, 568 deletions

diff --git a/contrib/python/ipython/py2/IPython/lib/demo.py b/contrib/python/ipython/py2/IPython/lib/demo.py
index b0f3503ed7..d630db99f9 100644
--- a/contrib/python/ipython/py2/IPython/lib/demo.py
+++ b/contrib/python/ipython/py2/IPython/lib/demo.py
@@ -1,583 +1,583 @@
-"""Module for interactive demos using IPython.
-
-This module implements a few classes for running Python scripts interactively
-in IPython for demonstrations.  With very simple markup (a few tags in
-comments), you can control points where the script stops executing and returns
-control to IPython.
-
-
-Provided classes
-----------------
-
-The classes are (see their docstrings for further details):
-
- - Demo: pure python demos
-
- - IPythonDemo: demos with input to be processed by IPython as if it had been
-   typed interactively (so magics work, as well as any other special syntax you
-   may have added via input prefilters).
-
- - LineDemo: single-line version of the Demo class.  These demos are executed
-   one line at a time, and require no markup.
-
- - IPythonLineDemo: IPython version of the LineDemo class (the demo is
-   executed a line at a time, but processed via IPython).
-
- - ClearMixin: mixin to make Demo classes with less visual clutter.  It
-   declares an empty marquee and a pre_cmd that clears the screen before each
-   block (see Subclassing below).
-
- - ClearDemo, ClearIPDemo: mixin-enabled versions of the Demo and IPythonDemo
-   classes.
-
-Inheritance diagram:
-
-.. inheritance-diagram:: IPython.lib.demo
-   :parts: 3
-
-Subclassing
------------
-
-The classes here all include a few methods meant to make customization by
-subclassing more convenient.  Their docstrings below have some more details:
-
-  - marquee(): generates a marquee to provide visible on-screen markers at each
-    block start and end.
-
-  - pre_cmd(): run right before the execution of each block.
-
-  - post_cmd(): run right after the execution of each block.  If the block
-    raises an exception, this is NOT called.
-
-
-Operation
----------
-
-The file is run in its own empty namespace (though you can pass it a string of
-arguments as if in a command line environment, and it will see those as
-sys.argv).  But at each stop, the global IPython namespace is updated with the
-current internal demo namespace, so you can work interactively with the data
-accumulated so far.
-
-By default, each block of code is printed (with syntax highlighting) before
-executing it and you have to confirm execution.  This is intended to show the
-code to an audience first so you can discuss it, and only proceed with
-execution once you agree.  There are a few tags which allow you to modify this
-behavior.
-
-The supported tags are:
-
-# <demo> stop
-
-  Defines block boundaries, the points where IPython stops execution of the
-  file and returns to the interactive prompt.
-
-  You can optionally mark the stop tag with extra dashes before and after the
-  word 'stop', to help visually distinguish the blocks in a text editor:
-
-  # <demo> --- stop ---
-
-
-# <demo> silent
-
-  Make a block execute silently (and hence automatically).  Typically used in
-  cases where you have some boilerplate or initialization code which you need
-  executed but do not want to be seen in the demo.
-
-# <demo> auto
-
-  Make a block execute automatically, but still being printed.  Useful for
-  simple code which does not warrant discussion, since it avoids the extra
-  manual confirmation.
-
-# <demo> auto_all
-
-  This tag can _only_ be in the first block, and if given it overrides the
-  individual auto tags to make the whole demo fully automatic (no block asks
-  for confirmation).  It can also be given at creation time (or the attribute
-  set later) to override what's in the file.
-
-While _any_ python file can be run as a Demo instance, if there are no stop
-tags the whole file will run in a single block (no different that calling
-first %pycat and then %run).  The minimal markup to make this useful is to
-place a set of stop tags; the other tags are only there to let you fine-tune
-the execution.
-
-This is probably best explained with the simple example file below.  You can
-copy this into a file named ex_demo.py, and try running it via::
-
+"""Module for interactive demos using IPython. 
+ 
+This module implements a few classes for running Python scripts interactively 
+in IPython for demonstrations.  With very simple markup (a few tags in 
+comments), you can control points where the script stops executing and returns 
+control to IPython. 
+ 
+ 
+Provided classes 
+---------------- 
+ 
+The classes are (see their docstrings for further details): 
+ 
+ - Demo: pure python demos 
+ 
+ - IPythonDemo: demos with input to be processed by IPython as if it had been 
+   typed interactively (so magics work, as well as any other special syntax you 
+   may have added via input prefilters). 
+ 
+ - LineDemo: single-line version of the Demo class.  These demos are executed 
+   one line at a time, and require no markup. 
+ 
+ - IPythonLineDemo: IPython version of the LineDemo class (the demo is 
+   executed a line at a time, but processed via IPython). 
+ 
+ - ClearMixin: mixin to make Demo classes with less visual clutter.  It 
+   declares an empty marquee and a pre_cmd that clears the screen before each 
+   block (see Subclassing below). 
+ 
+ - ClearDemo, ClearIPDemo: mixin-enabled versions of the Demo and IPythonDemo 
+   classes. 
+ 
+Inheritance diagram: 
+ 
+.. inheritance-diagram:: IPython.lib.demo 
+   :parts: 3 
+ 
+Subclassing 
+----------- 
+ 
+The classes here all include a few methods meant to make customization by 
+subclassing more convenient.  Their docstrings below have some more details: 
+ 
+  - marquee(): generates a marquee to provide visible on-screen markers at each 
+    block start and end. 
+ 
+  - pre_cmd(): run right before the execution of each block. 
+ 
+  - post_cmd(): run right after the execution of each block.  If the block 
+    raises an exception, this is NOT called. 
+ 
+ 
+Operation 
+--------- 
+ 
+The file is run in its own empty namespace (though you can pass it a string of 
+arguments as if in a command line environment, and it will see those as 
+sys.argv).  But at each stop, the global IPython namespace is updated with the 
+current internal demo namespace, so you can work interactively with the data 
+accumulated so far. 
+ 
+By default, each block of code is printed (with syntax highlighting) before 
+executing it and you have to confirm execution.  This is intended to show the 
+code to an audience first so you can discuss it, and only proceed with 
+execution once you agree.  There are a few tags which allow you to modify this 
+behavior. 
+ 
+The supported tags are: 
+ 
+# <demo> stop 
+ 
+  Defines block boundaries, the points where IPython stops execution of the 
+  file and returns to the interactive prompt. 
+ 
+  You can optionally mark the stop tag with extra dashes before and after the 
+  word 'stop', to help visually distinguish the blocks in a text editor: 
+ 
+  # <demo> --- stop --- 
+ 
+ 
+# <demo> silent 
+ 
+  Make a block execute silently (and hence automatically).  Typically used in 
+  cases where you have some boilerplate or initialization code which you need 
+  executed but do not want to be seen in the demo. 
+ 
+# <demo> auto 
+ 
+  Make a block execute automatically, but still being printed.  Useful for 
+  simple code which does not warrant discussion, since it avoids the extra 
+  manual confirmation. 
+ 
+# <demo> auto_all 
+ 
+  This tag can _only_ be in the first block, and if given it overrides the 
+  individual auto tags to make the whole demo fully automatic (no block asks 
+  for confirmation).  It can also be given at creation time (or the attribute 
+  set later) to override what's in the file. 
+ 
+While _any_ python file can be run as a Demo instance, if there are no stop 
+tags the whole file will run in a single block (no different that calling 
+first %pycat and then %run).  The minimal markup to make this useful is to 
+place a set of stop tags; the other tags are only there to let you fine-tune 
+the execution. 
+ 
+This is probably best explained with the simple example file below.  You can 
+copy this into a file named ex_demo.py, and try running it via:: 
+ 
     from IPython.lib.demo import Demo
-    d = Demo('ex_demo.py')
-    d()
-
-Each time you call the demo object, it runs the next block.  The demo object
-has a few useful methods for navigation, like again(), edit(), jump(), seek()
-and back().  It can be reset for a new run via reset() or reloaded from disk
-(in case you've edited the source) via reload().  See their docstrings below.
-
-Note: To make this simpler to explore, a file called "demo-exercizer.py" has
-been added to the "docs/examples/core" directory.  Just cd to this directory in
-an IPython session, and type::
-
-  %run demo-exercizer.py
-
-and then follow the directions.
-
-Example
--------
-
-The following is a very simple example of a valid demo file.
-
-::
-
-    #################### EXAMPLE DEMO <ex_demo.py> ###############################
-    '''A simple interactive demo to illustrate the use of IPython's Demo class.'''
-
-    print 'Hello, welcome to an interactive IPython demo.'
-
-    # The mark below defines a block boundary, which is a point where IPython will
-    # stop execution and return to the interactive prompt. The dashes are actually
-    # optional and used only as a visual aid to clearly separate blocks while
-    # editing the demo code.
-    # <demo> stop
-
-    x = 1
-    y = 2
-
-    # <demo> stop
-
-    # the mark below makes this block as silent
-    # <demo> silent
-
-    print 'This is a silent block, which gets executed but not printed.'
-
-    # <demo> stop
-    # <demo> auto
-    print 'This is an automatic block.'
-    print 'It is executed without asking for confirmation, but printed.'
-    z = x+y
-
-    print 'z=',x
-
-    # <demo> stop
-    # This is just another normal block.
-    print 'z is now:', z
-
-    print 'bye!'
-    ################### END EXAMPLE DEMO <ex_demo.py> ############################
-"""
-
-from __future__ import unicode_literals
-
-#*****************************************************************************
-#     Copyright (C) 2005-2006 Fernando Perez. <Fernando.Perez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#
-#*****************************************************************************
-from __future__ import print_function
-
-import os
-import re
-import shlex
-import sys
-
-from IPython.utils import io
-from IPython.utils.text import marquee
-from IPython.utils import openpy
-from IPython.utils import py3compat
-__all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
-
-class DemoError(Exception): pass
-
-def re_mark(mark):
-    return re.compile(r'^\s*#\s+<demo>\s+%s\s*$' % mark,re.MULTILINE)
-
-class Demo(object):
-
-    re_stop     = re_mark('-*\s?stop\s?-*')
-    re_silent   = re_mark('silent')
-    re_auto     = re_mark('auto')
-    re_auto_all = re_mark('auto_all')
-
-    def __init__(self,src,title='',arg_str='',auto_all=None):
-        """Make a new demo object.  To run the demo, simply call the object.
-
-        See the module docstring for full details and an example (you can use
-        IPython.Demo? in IPython to see it).
-
-        Inputs:
-
-          - src is either a file, or file-like object, or a
-              string that can be resolved to a filename.
-
-        Optional inputs:
-
-          - title: a string to use as the demo name.  Of most use when the demo
-            you are making comes from an object that has no filename, or if you
-            want an alternate denotation distinct from the filename.
-
-          - arg_str(''): a string of arguments, internally converted to a list
-            just like sys.argv, so the demo script can see a similar
-            environment.
-
-          - auto_all(None): global flag to run all blocks automatically without
-            confirmation.  This attribute overrides the block-level tags and
-            applies to the whole demo.  It is an attribute of the object, and
-            can be changed at runtime simply by reassigning it to a boolean
-            value.
-          """
-        if hasattr(src, "read"):
-             # It seems to be a file or a file-like object
-            self.fname = "from a file-like object"
-            if title == '':
-                self.title = "from a file-like object"
-            else:
-                self.title = title
-        else:
-             # Assume it's a string or something that can be converted to one
-            self.fname = src
-            if title == '':
-                (filepath, filename) = os.path.split(src)
-                self.title = filename
-            else:
-                self.title = title
-        self.sys_argv = [src] + shlex.split(arg_str)
-        self.auto_all = auto_all
-        self.src = src
-
-        # get a few things from ipython.  While it's a bit ugly design-wise,
-        # it ensures that things like color scheme and the like are always in
-        # sync with the ipython mode being used.  This class is only meant to
-        # be used inside ipython anyways,  so it's OK.
-        ip = get_ipython()  # this is in builtins whenever IPython is running
-        self.ip_ns       = ip.user_ns
-        self.ip_colorize = ip.pycolorize
-        self.ip_showtb   = ip.showtraceback
-        self.ip_run_cell = ip.run_cell
-        self.shell       = ip
-
-        # load user data and initialize data structures
-        self.reload()
-
-    def fload(self):
-        """Load file object."""
-        # read data and parse into blocks
-        if hasattr(self, 'fobj') and self.fobj is not None:
-           self.fobj.close()
-        if hasattr(self.src, "read"):
-             # It seems to be a file or a file-like object
-            self.fobj = self.src
-        else:
-             # Assume it's a string or something that can be converted to one
-            self.fobj = openpy.open(self.fname)
-
-    def reload(self):
-        """Reload source from disk and initialize state."""
-        self.fload()
-
-        self.src     = "".join(openpy.strip_encoding_cookie(self.fobj))
-        src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
-        self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
-        self._auto   = [bool(self.re_auto.findall(b)) for b in src_b]
-
-        # if auto_all is not given (def. None), we read it from the file
-        if self.auto_all is None:
-            self.auto_all = bool(self.re_auto_all.findall(src_b[0]))
-        else:
-            self.auto_all = bool(self.auto_all)
-
-        # Clean the sources from all markup so it doesn't get displayed when
-        # running the demo
-        src_blocks = []
-        auto_strip = lambda s: self.re_auto.sub('',s)
-        for i,b in enumerate(src_b):
-            if self._auto[i]:
-                src_blocks.append(auto_strip(b))
-            else:
-                src_blocks.append(b)
-        # remove the auto_all marker
-        src_blocks[0] = self.re_auto_all.sub('',src_blocks[0])
-
-        self.nblocks = len(src_blocks)
-        self.src_blocks = src_blocks
-
-        # also build syntax-highlighted source
-        self.src_blocks_colored = list(map(self.ip_colorize,self.src_blocks))
-
-        # ensure clean namespace and seek offset
-        self.reset()
-
-    def reset(self):
-        """Reset the namespace and seek pointer to restart the demo"""
-        self.user_ns     = {}
-        self.finished    = False
-        self.block_index = 0
-
-    def _validate_index(self,index):
-        if index<0 or index>=self.nblocks:
-            raise ValueError('invalid block index %s' % index)
-
-    def _get_index(self,index):
-        """Get the current block index, validating and checking status.
-
-        Returns None if the demo is finished"""
-
-        if index is None:
-            if self.finished:
+    d = Demo('ex_demo.py') 
+    d() 
+ 
+Each time you call the demo object, it runs the next block.  The demo object 
+has a few useful methods for navigation, like again(), edit(), jump(), seek() 
+and back().  It can be reset for a new run via reset() or reloaded from disk 
+(in case you've edited the source) via reload().  See their docstrings below. 
+ 
+Note: To make this simpler to explore, a file called "demo-exercizer.py" has 
+been added to the "docs/examples/core" directory.  Just cd to this directory in 
+an IPython session, and type:: 
+ 
+  %run demo-exercizer.py 
+ 
+and then follow the directions. 
+ 
+Example 
+------- 
+ 
+The following is a very simple example of a valid demo file. 
+ 
+:: 
+ 
+    #################### EXAMPLE DEMO <ex_demo.py> ############################### 
+    '''A simple interactive demo to illustrate the use of IPython's Demo class.''' 
+ 
+    print 'Hello, welcome to an interactive IPython demo.' 
+ 
+    # The mark below defines a block boundary, which is a point where IPython will 
+    # stop execution and return to the interactive prompt. The dashes are actually 
+    # optional and used only as a visual aid to clearly separate blocks while 
+    # editing the demo code. 
+    # <demo> stop 
+ 
+    x = 1 
+    y = 2 
+ 
+    # <demo> stop 
+ 
+    # the mark below makes this block as silent 
+    # <demo> silent 
+ 
+    print 'This is a silent block, which gets executed but not printed.' 
+ 
+    # <demo> stop 
+    # <demo> auto 
+    print 'This is an automatic block.' 
+    print 'It is executed without asking for confirmation, but printed.' 
+    z = x+y 
+ 
+    print 'z=',x 
+ 
+    # <demo> stop 
+    # This is just another normal block. 
+    print 'z is now:', z 
+ 
+    print 'bye!' 
+    ################### END EXAMPLE DEMO <ex_demo.py> ############################ 
+""" 
+ 
+from __future__ import unicode_literals 
+ 
+#***************************************************************************** 
+#     Copyright (C) 2005-2006 Fernando Perez. <Fernando.Perez@colorado.edu> 
+# 
+#  Distributed under the terms of the BSD License.  The full license is in 
+#  the file COPYING, distributed as part of this software. 
+# 
+#***************************************************************************** 
+from __future__ import print_function 
+ 
+import os 
+import re 
+import shlex 
+import sys 
+ 
+from IPython.utils import io 
+from IPython.utils.text import marquee 
+from IPython.utils import openpy 
+from IPython.utils import py3compat 
+__all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError'] 
+ 
+class DemoError(Exception): pass 
+ 
+def re_mark(mark): 
+    return re.compile(r'^\s*#\s+<demo>\s+%s\s*$' % mark,re.MULTILINE) 
+ 
+class Demo(object): 
+ 
+    re_stop     = re_mark('-*\s?stop\s?-*') 
+    re_silent   = re_mark('silent') 
+    re_auto     = re_mark('auto') 
+    re_auto_all = re_mark('auto_all') 
+ 
+    def __init__(self,src,title='',arg_str='',auto_all=None): 
+        """Make a new demo object.  To run the demo, simply call the object. 
+ 
+        See the module docstring for full details and an example (you can use 
+        IPython.Demo? in IPython to see it). 
+ 
+        Inputs: 
+ 
+          - src is either a file, or file-like object, or a 
+              string that can be resolved to a filename. 
+ 
+        Optional inputs: 
+ 
+          - title: a string to use as the demo name.  Of most use when the demo 
+            you are making comes from an object that has no filename, or if you 
+            want an alternate denotation distinct from the filename. 
+ 
+          - arg_str(''): a string of arguments, internally converted to a list 
+            just like sys.argv, so the demo script can see a similar 
+            environment. 
+ 
+          - auto_all(None): global flag to run all blocks automatically without 
+            confirmation.  This attribute overrides the block-level tags and 
+            applies to the whole demo.  It is an attribute of the object, and 
+            can be changed at runtime simply by reassigning it to a boolean 
+            value. 
+          """ 
+        if hasattr(src, "read"): 
+             # It seems to be a file or a file-like object 
+            self.fname = "from a file-like object" 
+            if title == '': 
+                self.title = "from a file-like object" 
+            else: 
+                self.title = title 
+        else: 
+             # Assume it's a string or something that can be converted to one 
+            self.fname = src 
+            if title == '': 
+                (filepath, filename) = os.path.split(src) 
+                self.title = filename 
+            else: 
+                self.title = title 
+        self.sys_argv = [src] + shlex.split(arg_str) 
+        self.auto_all = auto_all 
+        self.src = src 
+ 
+        # get a few things from ipython.  While it's a bit ugly design-wise, 
+        # it ensures that things like color scheme and the like are always in 
+        # sync with the ipython mode being used.  This class is only meant to 
+        # be used inside ipython anyways,  so it's OK. 
+        ip = get_ipython()  # this is in builtins whenever IPython is running 
+        self.ip_ns       = ip.user_ns 
+        self.ip_colorize = ip.pycolorize 
+        self.ip_showtb   = ip.showtraceback 
+        self.ip_run_cell = ip.run_cell 
+        self.shell       = ip 
+ 
+        # load user data and initialize data structures 
+        self.reload() 
+ 
+    def fload(self): 
+        """Load file object.""" 
+        # read data and parse into blocks 
+        if hasattr(self, 'fobj') and self.fobj is not None: 
+           self.fobj.close() 
+        if hasattr(self.src, "read"): 
+             # It seems to be a file or a file-like object 
+            self.fobj = self.src 
+        else: 
+             # Assume it's a string or something that can be converted to one 
+            self.fobj = openpy.open(self.fname) 
+ 
+    def reload(self): 
+        """Reload source from disk and initialize state.""" 
+        self.fload() 
+ 
+        self.src     = "".join(openpy.strip_encoding_cookie(self.fobj)) 
+        src_b        = [b.strip() for b in self.re_stop.split(self.src) if b] 
+        self._silent = [bool(self.re_silent.findall(b)) for b in src_b] 
+        self._auto   = [bool(self.re_auto.findall(b)) for b in src_b] 
+ 
+        # if auto_all is not given (def. None), we read it from the file 
+        if self.auto_all is None: 
+            self.auto_all = bool(self.re_auto_all.findall(src_b[0])) 
+        else: 
+            self.auto_all = bool(self.auto_all) 
+ 
+        # Clean the sources from all markup so it doesn't get displayed when 
+        # running the demo 
+        src_blocks = [] 
+        auto_strip = lambda s: self.re_auto.sub('',s) 
+        for i,b in enumerate(src_b): 
+            if self._auto[i]: 
+                src_blocks.append(auto_strip(b)) 
+            else: 
+                src_blocks.append(b) 
+        # remove the auto_all marker 
+        src_blocks[0] = self.re_auto_all.sub('',src_blocks[0]) 
+ 
+        self.nblocks = len(src_blocks) 
+        self.src_blocks = src_blocks 
+ 
+        # also build syntax-highlighted source 
+        self.src_blocks_colored = list(map(self.ip_colorize,self.src_blocks)) 
+ 
+        # ensure clean namespace and seek offset 
+        self.reset() 
+ 
+    def reset(self): 
+        """Reset the namespace and seek pointer to restart the demo""" 
+        self.user_ns     = {} 
+        self.finished    = False 
+        self.block_index = 0 
+ 
+    def _validate_index(self,index): 
+        if index<0 or index>=self.nblocks: 
+            raise ValueError('invalid block index %s' % index) 
+ 
+    def _get_index(self,index): 
+        """Get the current block index, validating and checking status. 
+ 
+        Returns None if the demo is finished""" 
+ 
+        if index is None: 
+            if self.finished: 
                 print('Demo finished.  Use <demo_name>.reset() if you want to rerun it.')
-                return None
-            index = self.block_index
-        else:
-            self._validate_index(index)
-        return index
-
-    def seek(self,index):
-        """Move the current seek pointer to the given block.
-
-        You can use negative indices to seek from the end, with identical
-        semantics to those of Python lists."""
-        if index<0:
-            index = self.nblocks + index
-        self._validate_index(index)
-        self.block_index = index
-        self.finished = False
-
-    def back(self,num=1):
-        """Move the seek pointer back num blocks (default is 1)."""
-        self.seek(self.block_index-num)
-
-    def jump(self,num=1):
-        """Jump a given number of blocks relative to the current one.
-
-        The offset can be positive or negative, defaults to 1."""
-        self.seek(self.block_index+num)
-
-    def again(self):
-        """Move the seek pointer back one block and re-execute."""
-        self.back(1)
-        self()
-
-    def edit(self,index=None):
-        """Edit a block.
-
-        If no number is given, use the last block executed.
-
-        This edits the in-memory copy of the demo, it does NOT modify the
-        original source file.  If you want to do that, simply open the file in
-        an editor and use reload() when you make changes to the file.  This
-        method is meant to let you change a block during a demonstration for
-        explanatory purposes, without damaging your original script."""
-
-        index = self._get_index(index)
-        if index is None:
-            return
-        # decrease the index by one (unless we're at the very beginning), so
-        # that the default demo.edit() call opens up the sblock we've last run
-        if index>0:
-            index -= 1
-
-        filename = self.shell.mktempfile(self.src_blocks[index])
-        self.shell.hooks.editor(filename,1)
-        with open(filename, 'r') as f:
-            new_block = f.read()
-        # update the source and colored block
-        self.src_blocks[index] = new_block
-        self.src_blocks_colored[index] = self.ip_colorize(new_block)
-        self.block_index = index
-        # call to run with the newly edited index
-        self()
-
-    def show(self,index=None):
-        """Show a single block on screen"""
-
-        index = self._get_index(index)
-        if index is None:
-            return
-
-        print(self.marquee('<%s> block # %s (%s remaining)' %
+                return None 
+            index = self.block_index 
+        else: 
+            self._validate_index(index) 
+        return index 
+ 
+    def seek(self,index): 
+        """Move the current seek pointer to the given block. 
+ 
+        You can use negative indices to seek from the end, with identical 
+        semantics to those of Python lists.""" 
+        if index<0: 
+            index = self.nblocks + index 
+        self._validate_index(index) 
+        self.block_index = index 
+        self.finished = False 
+ 
+    def back(self,num=1): 
+        """Move the seek pointer back num blocks (default is 1).""" 
+        self.seek(self.block_index-num) 
+ 
+    def jump(self,num=1): 
+        """Jump a given number of blocks relative to the current one. 
+ 
+        The offset can be positive or negative, defaults to 1.""" 
+        self.seek(self.block_index+num) 
+ 
+    def again(self): 
+        """Move the seek pointer back one block and re-execute.""" 
+        self.back(1) 
+        self() 
+ 
+    def edit(self,index=None): 
+        """Edit a block. 
+ 
+        If no number is given, use the last block executed. 
+ 
+        This edits the in-memory copy of the demo, it does NOT modify the 
+        original source file.  If you want to do that, simply open the file in 
+        an editor and use reload() when you make changes to the file.  This 
+        method is meant to let you change a block during a demonstration for 
+        explanatory purposes, without damaging your original script.""" 
+ 
+        index = self._get_index(index) 
+        if index is None: 
+            return 
+        # decrease the index by one (unless we're at the very beginning), so 
+        # that the default demo.edit() call opens up the sblock we've last run 
+        if index>0: 
+            index -= 1 
+ 
+        filename = self.shell.mktempfile(self.src_blocks[index]) 
+        self.shell.hooks.editor(filename,1) 
+        with open(filename, 'r') as f: 
+            new_block = f.read() 
+        # update the source and colored block 
+        self.src_blocks[index] = new_block 
+        self.src_blocks_colored[index] = self.ip_colorize(new_block) 
+        self.block_index = index 
+        # call to run with the newly edited index 
+        self() 
+ 
+    def show(self,index=None): 
+        """Show a single block on screen""" 
+ 
+        index = self._get_index(index) 
+        if index is None: 
+            return 
+ 
+        print(self.marquee('<%s> block # %s (%s remaining)' % 
                            (self.title,index,self.nblocks-index-1)))
         print(self.src_blocks_colored[index])
-        sys.stdout.flush()
-
-    def show_all(self):
-        """Show entire demo on screen, block by block"""
-
-        fname = self.title
-        title = self.title
-        nblocks = self.nblocks
-        silent = self._silent
-        marquee = self.marquee
-        for index,block in enumerate(self.src_blocks_colored):
-            if silent[index]:
-                print(marquee('<%s> SILENT block # %s (%s remaining)' %
+        sys.stdout.flush() 
+ 
+    def show_all(self): 
+        """Show entire demo on screen, block by block""" 
+ 
+        fname = self.title 
+        title = self.title 
+        nblocks = self.nblocks 
+        silent = self._silent 
+        marquee = self.marquee 
+        for index,block in enumerate(self.src_blocks_colored): 
+            if silent[index]: 
+                print(marquee('<%s> SILENT block # %s (%s remaining)' % 
                               (title,index,nblocks-index-1)))
-            else:
-                print(marquee('<%s> block # %s (%s remaining)' %
+            else: 
+                print(marquee('<%s> block # %s (%s remaining)' % 
                               (title,index,nblocks-index-1)))
             print(block, end=' ')
-        sys.stdout.flush()
-
-    def run_cell(self,source):
-        """Execute a string with one or more lines of code"""
-
-        exec(source, self.user_ns)
-
-    def __call__(self,index=None):
-        """run a block of the demo.
-
-        If index is given, it should be an integer >=1 and <= nblocks.  This
-        means that the calling convention is one off from typical Python
-        lists.  The reason for the inconsistency is that the demo always
-        prints 'Block n/N, and N is the total, so it would be very odd to use
-        zero-indexing here."""
-
-        index = self._get_index(index)
-        if index is None:
-            return
-        try:
-            marquee = self.marquee
-            next_block = self.src_blocks[index]
-            self.block_index += 1
-            if self._silent[index]:
-                print(marquee('Executing silent block # %s (%s remaining)' %
+        sys.stdout.flush() 
+ 
+    def run_cell(self,source): 
+        """Execute a string with one or more lines of code""" 
+ 
+        exec(source, self.user_ns) 
+ 
+    def __call__(self,index=None): 
+        """run a block of the demo. 
+ 
+        If index is given, it should be an integer >=1 and <= nblocks.  This 
+        means that the calling convention is one off from typical Python 
+        lists.  The reason for the inconsistency is that the demo always 
+        prints 'Block n/N, and N is the total, so it would be very odd to use 
+        zero-indexing here.""" 
+ 
+        index = self._get_index(index) 
+        if index is None: 
+            return 
+        try: 
+            marquee = self.marquee 
+            next_block = self.src_blocks[index] 
+            self.block_index += 1 
+            if self._silent[index]: 
+                print(marquee('Executing silent block # %s (%s remaining)' % 
                               (index,self.nblocks-index-1)))
-            else:
-                self.pre_cmd()
-                self.show(index)
-                if self.auto_all or self._auto[index]:
+            else: 
+                self.pre_cmd() 
+                self.show(index) 
+                if self.auto_all or self._auto[index]: 
                     print(marquee('output:'))
-                else:
+                else: 
                     print(marquee('Press <q> to quit, <Enter> to execute...'), end=' ')
-                    ans = py3compat.input().strip()
-                    if ans:
+                    ans = py3compat.input().strip() 
+                    if ans: 
                         print(marquee('Block NOT executed'))
-                        return
-            try:
-                save_argv = sys.argv
-                sys.argv = self.sys_argv
-                self.run_cell(next_block)
-                self.post_cmd()
-            finally:
-                sys.argv = save_argv
-
-        except:
-            self.ip_showtb(filename=self.fname)
-        else:
-            self.ip_ns.update(self.user_ns)
-
-        if self.block_index == self.nblocks:
-            mq1 = self.marquee('END OF DEMO')
-            if mq1:
+                        return 
+            try: 
+                save_argv = sys.argv 
+                sys.argv = self.sys_argv 
+                self.run_cell(next_block) 
+                self.post_cmd() 
+            finally: 
+                sys.argv = save_argv 
+ 
+        except: 
+            self.ip_showtb(filename=self.fname) 
+        else: 
+            self.ip_ns.update(self.user_ns) 
+ 
+        if self.block_index == self.nblocks: 
+            mq1 = self.marquee('END OF DEMO') 
+            if mq1: 
                 # avoid spurious print if empty marquees are used
                 print()
                 print(mq1)
                 print(self.marquee('Use <demo_name>.reset() if you want to rerun it.'))
-            self.finished = True
-
-    # These methods are meant to be overridden by subclasses who may wish to
-    # customize the behavior of of their demos.
-    def marquee(self,txt='',width=78,mark='*'):
-        """Return the input string centered in a 'marquee'."""
-        return marquee(txt,width,mark)
-
-    def pre_cmd(self):
-        """Method called before executing each block."""
-        pass
-
-    def post_cmd(self):
-        """Method called after executing each block."""
-        pass
-
-
-class IPythonDemo(Demo):
-    """Class for interactive demos with IPython's input processing applied.
-
-    This subclasses Demo, but instead of executing each block by the Python
-    interpreter (via exec), it actually calls IPython on it, so that any input
-    filters which may be in place are applied to the input block.
-
-    If you have an interactive environment which exposes special input
-    processing, you can use this class instead to write demo scripts which
-    operate exactly as if you had typed them interactively.  The default Demo
-    class requires the input to be valid, pure Python code.
-    """
-
-    def run_cell(self,source):
-        """Execute a string with one or more lines of code"""
-
-        self.shell.run_cell(source)
-
-class LineDemo(Demo):
-    """Demo where each line is executed as a separate block.
-
-    The input script should be valid Python code.
-
-    This class doesn't require any markup at all, and it's meant for simple
-    scripts (with no nesting or any kind of indentation) which consist of
-    multiple lines of input to be executed, one at a time, as if they had been
-    typed in the interactive prompt.
-
-    Note: the input can not have *any* indentation, which means that only
-    single-lines of input are accepted, not even function definitions are
-    valid."""
-
-    def reload(self):
-        """Reload source from disk and initialize state."""
-        # read data and parse into blocks
-        self.fload()
-        lines           = self.fobj.readlines()
-        src_b           = [l for l in lines if l.strip()]
-        nblocks         = len(src_b)
-        self.src        = ''.join(lines)
-        self._silent    = [False]*nblocks
-        self._auto      = [True]*nblocks
-        self.auto_all   = True
-        self.nblocks    = nblocks
-        self.src_blocks = src_b
-
-        # also build syntax-highlighted source
-        self.src_blocks_colored = map(self.ip_colorize,self.src_blocks)
-
-        # ensure clean namespace and seek offset
-        self.reset()
-
-
-class IPythonLineDemo(IPythonDemo,LineDemo):
-    """Variant of the LineDemo class whose input is processed by IPython."""
-    pass
-
-
-class ClearMixin(object):
-    """Use this mixin to make Demo classes with less visual clutter.
-
-    Demos using this mixin will clear the screen before every block and use
-    blank marquees.
-
-    Note that in order for the methods defined here to actually override those
-    of the classes it's mixed with, it must go /first/ in the inheritance
-    tree.  For example:
-
-        class ClearIPDemo(ClearMixin,IPythonDemo): pass
-
-    will provide an IPythonDemo class with the mixin's features.
-    """
-
-    def marquee(self,txt='',width=78,mark='*'):
-        """Blank marquee that returns '' no matter what the input."""
-        return ''
-
-    def pre_cmd(self):
-        """Method called before executing each block.
-
-        This one simply clears the screen."""
-        from IPython.utils.terminal import term_clear
-        term_clear()
-
-class ClearDemo(ClearMixin,Demo):
-    pass
-
-
-class ClearIPDemo(ClearMixin,IPythonDemo):
-    pass
+            self.finished = True 
+ 
+    # These methods are meant to be overridden by subclasses who may wish to 
+    # customize the behavior of of their demos. 
+    def marquee(self,txt='',width=78,mark='*'): 
+        """Return the input string centered in a 'marquee'.""" 
+        return marquee(txt,width,mark) 
+ 
+    def pre_cmd(self): 
+        """Method called before executing each block.""" 
+        pass 
+ 
+    def post_cmd(self): 
+        """Method called after executing each block.""" 
+        pass 
+ 
+ 
+class IPythonDemo(Demo): 
+    """Class for interactive demos with IPython's input processing applied. 
+ 
+    This subclasses Demo, but instead of executing each block by the Python 
+    interpreter (via exec), it actually calls IPython on it, so that any input 
+    filters which may be in place are applied to the input block. 
+ 
+    If you have an interactive environment which exposes special input 
+    processing, you can use this class instead to write demo scripts which 
+    operate exactly as if you had typed them interactively.  The default Demo 
+    class requires the input to be valid, pure Python code. 
+    """ 
+ 
+    def run_cell(self,source): 
+        """Execute a string with one or more lines of code""" 
+ 
+        self.shell.run_cell(source) 
+ 
+class LineDemo(Demo): 
+    """Demo where each line is executed as a separate block. 
+ 
+    The input script should be valid Python code. 
+ 
+    This class doesn't require any markup at all, and it's meant for simple 
+    scripts (with no nesting or any kind of indentation) which consist of 
+    multiple lines of input to be executed, one at a time, as if they had been 
+    typed in the interactive prompt. 
+ 
+    Note: the input can not have *any* indentation, which means that only 
+    single-lines of input are accepted, not even function definitions are 
+    valid.""" 
+ 
+    def reload(self): 
+        """Reload source from disk and initialize state.""" 
+        # read data and parse into blocks 
+        self.fload() 
+        lines           = self.fobj.readlines() 
+        src_b           = [l for l in lines if l.strip()] 
+        nblocks         = len(src_b) 
+        self.src        = ''.join(lines) 
+        self._silent    = [False]*nblocks 
+        self._auto      = [True]*nblocks 
+        self.auto_all   = True 
+        self.nblocks    = nblocks 
+        self.src_blocks = src_b 
+ 
+        # also build syntax-highlighted source 
+        self.src_blocks_colored = map(self.ip_colorize,self.src_blocks) 
+ 
+        # ensure clean namespace and seek offset 
+        self.reset() 
+ 
+ 
+class IPythonLineDemo(IPythonDemo,LineDemo): 
+    """Variant of the LineDemo class whose input is processed by IPython.""" 
+    pass 
+ 
+ 
+class ClearMixin(object): 
+    """Use this mixin to make Demo classes with less visual clutter. 
+ 
+    Demos using this mixin will clear the screen before every block and use 
+    blank marquees. 
+ 
+    Note that in order for the methods defined here to actually override those 
+    of the classes it's mixed with, it must go /first/ in the inheritance 
+    tree.  For example: 
+ 
+        class ClearIPDemo(ClearMixin,IPythonDemo): pass 
+ 
+    will provide an IPythonDemo class with the mixin's features. 
+    """ 
+ 
+    def marquee(self,txt='',width=78,mark='*'): 
+        """Blank marquee that returns '' no matter what the input.""" 
+        return '' 
+ 
+    def pre_cmd(self): 
+        """Method called before executing each block. 
+ 
+        This one simply clears the screen.""" 
+        from IPython.utils.terminal import term_clear 
+        term_clear() 
+ 
+class ClearDemo(ClearMixin,Demo): 
+    pass 
+ 
+ 
+class ClearIPDemo(ClearMixin,IPythonDemo): 
+    pass