Merging -r 1178 from lp:ipython.

No major conflicts.

docs/examples/core/demo-exercizer.py

@@ -0,0 +1,85 b''
+"""This is meant to be run from the IPython prompt:
+
+%run demo-exercizer.py
+
+It will create demo objects of the example that is embedded in demo.py in a
+number of ways and allow you to see how they work, just follow the printed
+directions."""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# From std lib
+import StringIO
+import os
+import shutil
+import tempfile
+
+# From IPython
+from IPython.demo import (Demo, IPythonDemo, LineDemo, IPythonLineDemo,
+                          ClearDemo, ClearIPDemo)
+
+#-----------------------------------------------------------------------------
+# Demo code
+#-----------------------------------------------------------------------------
+
+example1 = """
+'''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!'
+"""
+fp = tempfile.mkdtemp(prefix = 'DemoTmp')
+fd, filename = tempfile.mkstemp(prefix = 'demoExample1File', suffix = '.py',
+                                dir = fp)
+f = os.fdopen(fd, 'wt')
+
+f.write(example1)
+f.close()
+
+my_d = Demo(filename)
+my_cd = ClearDemo(filename)
+
+fobj = StringIO.StringIO(example1)
+str_d = Demo(fobj, title='via stringio')
+
+print '''
+The example that is embeded in demo.py file has been used to create 
+the following 3 demos, and should now be available to use:
+   my_d()    -- created from a file
+   my_cd()   -- created from a file, a ClearDemo
+   str_d()   -- same as above, but created via a StringIO object 
+Call by typing their name, (with parentheses), at the 
+ipython prompt, interact with the block, then call again
+to run the next block.
+'''

IPython/lib/demo.py

@@ -1,526 +1,554 b''
 """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.
 
 
 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.demo import Demo
 d = Demo('ex_demo.py')
 d()  <--- Call the d object (omit the parens if you have autocall set to 2).
 
 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.
+# 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> ############################
 """
 
 #*****************************************************************************
 #     Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #
 #*****************************************************************************
 
 import exceptions
 import os
 import re
 import shlex
 import sys
 
 from IPython.utils.PyColorize import Parser
-from IPython.utils.genutils import marquee, file_read, file_readlines
+from IPython.utils.genutils import marquee, file_read, file_readlines, Term
 
 __all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
 
 class DemoError(exceptions.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,fname,arg_str='',auto_all=None):
+    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:
         
-          - fname = filename.
+          - 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.
           """
-        
-        self.fname    = fname
-        self.sys_argv = [fname] + shlex.split(arg_str)
+        if hasattr(src, "read"):
+             # It seems to be a file or a file-like object
+            self.fobj = src
+            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.fobj = open(src)
+            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
         
         # 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.
         self.ip_ns       = __IPYTHON__.user_ns
         self.ip_colorize = __IPYTHON__.pycolorize
         self.ip_showtb   = __IPYTHON__.showtraceback
         self.ip_runlines = __IPYTHON__.runlines
         self.shell       = __IPYTHON__
 
         # load user data and initialize data structures
         self.reload()
 
     def reload(self):
         """Reload source from disk and initialize state."""
         # read data and parse into blocks
-        self.src     = file_read(self.fname)
+        self.src     = self.fobj.read()
         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 = 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 reset() if you want to rerun it.'
+                print >>Term.cout, '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)
         new_block = file_read(filename)
         # 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.fname,index,self.nblocks-index-1))
-        sys.stdout.write(self.src_blocks_colored[index])
+        print >>Term.cout, self.marquee('<%s> block # %s (%s remaining)' %
+                           (self.title,index,self.nblocks-index-1))
+        print >>Term.cout,(self.src_blocks_colored[index])
         sys.stdout.flush()
 
     def show_all(self):
         """Show entire demo on screen, block by block"""
 
-        fname = self.fname
+        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)' %
-                              (fname,index,nblocks-index-1))
+                print >>Term.cout, marquee('<%s> SILENT block # %s (%s remaining)' %
+                              (title,index,nblocks-index-1))
             else:
-                print marquee('<%s> block # %s (%s remaining)' %
-                              (fname,index,nblocks-index-1))
-            print block,
+                print >>Term.cout, marquee('<%s> block # %s (%s remaining)' %
+                              (title,index,nblocks-index-1))
+            print >>Term.cout, block,
         sys.stdout.flush()
 
     def runlines(self,source):
         """Execute a string with one or more lines of code"""
 
         exec source in 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)' %
+                print >>Term.cout, 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:')
+                    print >>Term.cout, marquee('output:')
                 else:
-                    print marquee('Press <q> to quit, <Enter> to execute...'),
+                    print >>Term.cout, marquee('Press <q> to quit, <Enter> to execute...'),
                     ans = raw_input().strip()
                     if ans:
-                        print marquee('Block NOT executed')
+                        print >>Term.cout, marquee('Block NOT executed')
                         return
             try:
                 save_argv = sys.argv
                 sys.argv = self.sys_argv
                 self.runlines(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 prints if empty marquees are used
-                print
-                print mq1
-                print self.marquee('Use reset() if you want to rerun it.')
+                # avoid spurious print >>Term.cout,s if empty marquees are used
+                print >>Term.cout
+                print >>Term.cout, mq1
+                print >>Term.cout, 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 runlines(self,source):
         """Execute a string with one or more lines of code"""
 
         self.shell.runlines(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."""
     
     def reload(self):
         """Reload source from disk and initialize state."""
         # read data and parse into blocks
-        src_b           = [l for l in file_readlines(self.fname) if l.strip()]
+        src_b           = [l for l in self.fobj.readline() if l.strip()]
         nblocks         = len(src_b)
-        self.src        = os.linesep.join(file_readlines(self.fname))
+        self.src        = os.linesep.join(self.fobj.readlines())
         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."""
-        os.system('clear')
-
+        from IPython.utils.platutils import term_clear
+        term_clear()
 
 class ClearDemo(ClearMixin,Demo):
     pass
 
 
 class ClearIPDemo(ClearMixin,IPythonDemo):
     pass

IPython/utils/platutils.py

@@ -1,106 +1,109 b''
 # -*- coding: utf-8 -*-
 """ Proxy module for accessing platform specific utility functions. 
 
 Importing this module should give you the implementations that are correct 
 for your operation system, from platutils_PLATFORMNAME module.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 import os
 import sys
 import warnings
 
 # Import the platform-specific implementations
 if os.name == 'posix':
     import platutils_posix as _platutils
 elif sys.platform == 'win32':
     import platutils_win32 as _platutils
 else:
     import platutils_dummy as _platutils
     import warnings
     warnings.warn("Platutils not available for platform '%s', some features may be missing" %
         os.name)
     del warnings
 
 
 # Functionality that's logically common to all platforms goes here, each
 # platform-specific module only provides the bits that are OS-dependent.
 
 # XXX - I'm still not happy with a module global for this, but at least now
 # there is a public, cross-platform way of toggling the term title control on
 # and off.  We should make this a stateful object later on so that each user
 # can have its own instance if needed.
+def term_clear():
+    _platutils.term_clear()
+
 def toggle_set_term_title(val):
     """Control whether set_term_title is active or not.
 
     set_term_title() allows writing to the console titlebar.  In embedded
     widgets this can cause problems, so this call can be used to toggle it on
     or off as needed.
 
     The default state of the module is for the function to be disabled.
 
     Parameters
     ----------
       val : bool
         If True, set_term_title() actually writes to the terminal (using the
         appropriate platform-specific module).  If False, it is a no-op.
     """
     _platutils.ignore_termtitle = not(val)
 
 
 def set_term_title(title):
     """Set terminal title using the necessary platform-dependent calls."""
 
     if _platutils.ignore_termtitle:
         return
     _platutils.set_term_title(title)
 
 
 class FindCmdError(Exception):
     pass
 
 def find_cmd(cmd):
     """Find full path to executable cmd in a cross platform manner.
     
     This function tries to determine the full path to a command line program
     using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
     time it will use the version that is first on the users `PATH`.  If
     cmd is `python` return `sys.executable`.
 
     Parameters
     ----------
     cmd : str
         The command line program to look for.
     """
     if cmd == 'python':
         return sys.executable
     try:
         path = _platutils.find_cmd(cmd)
     except:
         raise FindCmdError('command could not be found: %s' % cmd)
     # which returns empty if not found
     if path == '':
         raise FindCmdError('command could not be found: %s' % cmd)
     return path
 
 def get_long_path_name(path):
     """Expand a path into its long form.
 
     On Windows this expands any ~ in the paths. On other platforms, it is
     a null operation.
     """
     return _platutils.get_long_path_name(path)
 
 #-----------------------------------------------------------------------------
 # Deprecated functions
 #-----------------------------------------------------------------------------
 def freeze_term_title():
+    import warnings
     warnings.warn("This function is deprecated, use toggle_set_term_title()")
     _platutils.ignore_termtitle = True
-

IPython/utils/platutils_posix.py

@@ -1,40 +1,47 b''
 # -*- coding: utf-8 -*-
 """ Platform specific utility functions, posix version 
 
 Importing this module directly is not portable - rather, import platutils 
 to use these functions in platform agnostic fashion.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 import sys
 import os
 
 ignore_termtitle = True
 
 def _dummy_op(*a, **b):
     """ A no-op function """
 
+
 def _set_term_title_xterm(title):
     """ Change virtual terminal title in xterm-workalikes """
 
     sys.stdout.write('\033]0;%s\007' % title)
 
 
 if os.environ.get('TERM','') == 'xterm':
     set_term_title = _set_term_title_xterm
 else:
     set_term_title = _dummy_op
 
+
 def find_cmd(cmd):
     """Find the full path to a command using which."""
     return os.popen('which %s' % cmd).read().strip()
 
+
 def get_long_path_name(path):
     """Dummy no-op."""
     return path
+
+
+def term_clear():
+    os.system('clear')

IPython/utils/platutils_win32.py

@@ -1,82 +1,87 b''
 # -*- coding: utf-8 -*-
 """ Platform specific utility functions, win32 version
 
 Importing this module directly is not portable - rather, import platutils 
 to use these functions in platform agnostic fashion.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 import os
 
 ignore_termtitle = True
 
 try:
     import ctypes
 
     SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
     SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
     
     def set_term_title(title):
         """Set terminal title using ctypes to access the Win32 APIs."""
         SetConsoleTitleW(title)
 
 except ImportError:
     def set_term_title(title):
         """Set terminal title using the 'title' command."""
         global ignore_termtitle
 
         try:
             # Cannot be on network share when issuing system commands
             curr = os.getcwd()
             os.chdir("C:")
             ret = os.system("title " + title)
         finally:
             os.chdir(curr)
         if ret:
             # non-zero return code signals error, don't try again
             ignore_termtitle = True
 
+
 def find_cmd(cmd):
     """Find the full path to a .bat or .exe using the win32api module."""
     try:
         import win32api
     except ImportError:
         raise ImportError('you need to have pywin32 installed for this to work')
     else:
         try:
             (path, offest) = win32api.SearchPath(os.environ['PATH'],cmd + '.exe')
         except:
             (path, offset) = win32api.SearchPath(os.environ['PATH'],cmd + '.bat')
     return path
 
 
 def get_long_path_name(path):
     """Get a long path name (expand ~) on Windows using ctypes.
 
     Examples
     --------
 
     >>> get_long_path_name('c:\\docume~1')
     u'c:\\\\Documents and Settings'
 
     """
     try:
         import ctypes
     except ImportError:
         raise ImportError('you need to have ctypes installed for this to work')
     _GetLongPathName = ctypes.windll.kernel32.GetLongPathNameW
     _GetLongPathName.argtypes = [ctypes.c_wchar_p, ctypes.c_wchar_p,
         ctypes.c_uint ]
 
     buf = ctypes.create_unicode_buffer(260)
     rv = _GetLongPathName(path, buf, 260)
     if rv == 0 or rv > 260:
         return path
     else:
         return buf.value
+
+
+def term_clear():
+    os.system('cls')