fix ya.make

1 files changed, 0 insertions, 583 deletions

diff --git a/contrib/python/ipython/py2/IPython/lib/demo.py b/contrib/python/ipython/py2/IPython/lib/demo.py
deleted file mode 100644
index b0f3503ed7..0000000000
--- a/contrib/python/ipython/py2/IPython/lib/demo.py
+++ /dev/null
@@ -1,583 +0,0 @@
-"""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:
-                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)' %
-                           (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)' %
-                              (title,index,nblocks-index-1)))
-            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)' %
-                              (index,self.nblocks-index-1)))
-            else:
-                self.pre_cmd()
-                self.show(index)
-                if self.auto_all or self._auto[index]:
-                    print(marquee('output:'))
-                else:
-                    print(marquee('Press <q> to quit, <Enter> to execute...'), end=' ')
-                    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:
-                # 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