Arnd's wxversion support.

IPython/Shell.py

@@ -1,917 +1,933 b''
 # -*- coding: utf-8 -*-
 """IPython Shell classes.
 
 All the matplotlib support code was co-developed with John Hunter,
 matplotlib's author.
 
-$Id: Shell.py 994 2006-01-08 08:29:44Z fperez $"""
+$Id: Shell.py 998 2006-01-09 06:57:40Z fperez $"""
 
 #*****************************************************************************
 #       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.
 #*****************************************************************************
 
 from IPython import Release
 __author__  = '%s <%s>' % Release.authors['Fernando']
 __license__ = Release.license
 
 # Code begins
 import __main__
 import __builtin__
 import os
 import sys
 import signal
 import threading
 
 import IPython
 from IPython import ultraTB
 from IPython.genutils import Term,warn,error,flag_calls
 from IPython.iplib import InteractiveShell
 from IPython.ipmaker import make_IPython
 from IPython.Magic import Magic
 from IPython.Struct import Struct
 
 # global flag to pass around information about Ctrl-C without exceptions
 KBINT = False
 
 # global flag to turn on/off Tk support.
 USE_TK = False
 
 #-----------------------------------------------------------------------------
 # This class is trivial now, but I want to have it in to publish a clean
 # interface. Later when the internals are reorganized, code that uses this
 # shouldn't have to change.
 
 class IPShell:
     """Create an IPython instance."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=1,shell_class=InteractiveShell):
         self.IP = make_IPython(argv,user_ns=user_ns,user_global_ns=user_global_ns,
                                debug=debug,shell_class=shell_class)
 
     def mainloop(self,sys_exit=0,banner=None):
         self.IP.mainloop(banner)
         if sys_exit:
             sys.exit()
 
 #-----------------------------------------------------------------------------
 class IPShellEmbed:
     """Allow embedding an IPython shell into a running program.
 
     Instances of this class are callable, with the __call__ method being an
     alias to the embed() method of an InteractiveShell instance.
 
     Usage (see also the example-embed.py file for a running example):
 
     ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
 
     - argv: list containing valid command-line options for IPython, as they
     would appear in sys.argv[1:].
 
     For example, the following command-line options:
 
       $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
 
     would be passed in the argv list as:
 
       ['-prompt_in1','Input <\\#>','-colors','LightBG']
 
     - banner: string which gets printed every time the interpreter starts.
 
     - exit_msg: string which gets printed every time the interpreter exits.
 
     - rc_override: a dict or Struct of configuration options such as those
     used by IPython. These options are read from your ~/.ipython/ipythonrc
     file when the Shell object is created. Passing an explicit rc_override
     dict with any options you want allows you to override those values at
     creation time without having to modify the file. This way you can create
     embeddable instances configured in any way you want without editing any
     global files (thus keeping your interactive IPython configuration
     unchanged).
 
     Then the ipshell instance can be called anywhere inside your code:
     
     ipshell(header='') -> Opens up an IPython shell.
 
     - header: string printed by the IPython shell upon startup. This can let
     you know where in your code you are when dropping into the shell. Note
     that 'banner' gets prepended to all calls, so header is used for
     location-specific information.
 
     For more details, see the __call__ method below.
 
     When the IPython shell is exited with Ctrl-D, normal program execution
     resumes.
 
     This functionality was inspired by a posting on comp.lang.python by cmkl
     <[e-mail]> on Dec. 06/01 concerning similar uses of pyrepl, and
     by the IDL stop/continue commands."""
 
     def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None):
         """Note that argv here is a string, NOT a list."""
         self.set_banner(banner)
         self.set_exit_msg(exit_msg)
         self.set_dummy_mode(0)
 
         # sys.displayhook is a global, we need to save the user's original
         # Don't rely on __displayhook__, as the user may have changed that.
         self.sys_displayhook_ori = sys.displayhook
 
         # save readline completer status
         try:
             #print 'Save completer',sys.ipcompleter  # dbg
             self.sys_ipcompleter_ori = sys.ipcompleter
         except:
             pass # not nested with IPython
         
         # FIXME. Passing user_ns breaks namespace handling.
         #self.IP = make_IPython(argv,user_ns=__main__.__dict__)
         self.IP = make_IPython(argv,rc_override=rc_override,embedded=True)
 
         # copy our own displayhook also
         self.sys_displayhook_embed = sys.displayhook
         # and leave the system's display hook clean
         sys.displayhook = self.sys_displayhook_ori
         # don't use the ipython crash handler so that user exceptions aren't
         # trapped
         sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
                                              mode = self.IP.rc.xmode,
                                              call_pdb = self.IP.rc.pdb)
         self.restore_system_completer()
 
     def restore_system_completer(self):
         """Restores the readline completer which was in place.
 
         This allows embedded IPython within IPython not to disrupt the
         parent's completion.
         """
         
         try:
             self.IP.readline.set_completer(self.sys_ipcompleter_ori)
             sys.ipcompleter = self.sys_ipcompleter_ori
         except:
             pass
 
     def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
         """Activate the interactive interpreter.
 
         __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
         the interpreter shell with the given local and global namespaces, and
         optionally print a header string at startup.
 
         The shell can be globally activated/deactivated using the
         set/get_dummy_mode methods. This allows you to turn off a shell used
         for debugging globally.
 
         However, *each* time you call the shell you can override the current
         state of dummy_mode with the optional keyword parameter 'dummy'. For
         example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
         can still have a specific call work by making it as IPShell(dummy=0).
 
         The optional keyword parameter dummy controls whether the call
         actually does anything.  """
 
         # Allow the dummy parameter to override the global __dummy_mode
         if dummy or (dummy != 0 and self.__dummy_mode):
             return
 
         # Set global subsystems (display,completions) to our values
         sys.displayhook = self.sys_displayhook_embed
         if self.IP.has_readline:
             self.IP.readline.set_completer(self.IP.Completer.complete)
 
         if self.banner and header:
             format = '%s\n%s\n'
         else:
             format = '%s%s\n'
         banner =  format % (self.banner,header)
 
         # Call the embedding code with a stack depth of 1 so it can skip over
         # our call and get the original caller's namespaces.
         self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
 
         if self.exit_msg:
             print self.exit_msg
             
         # Restore global systems (display, completion)
         sys.displayhook = self.sys_displayhook_ori
         self.restore_system_completer()
     
     def set_dummy_mode(self,dummy):
         """Sets the embeddable shell's dummy mode parameter.
 
         set_dummy_mode(dummy): dummy = 0 or 1.
 
         This parameter is persistent and makes calls to the embeddable shell
         silently return without performing any action. This allows you to
         globally activate or deactivate a shell you're using with a single call.
 
         If you need to manually"""
 
         if dummy not in [0,1,False,True]:
             raise ValueError,'dummy parameter must be boolean'
         self.__dummy_mode = dummy
 
     def get_dummy_mode(self):
         """Return the current value of the dummy mode parameter.
         """
         return self.__dummy_mode
     
     def set_banner(self,banner):
         """Sets the global banner.
 
         This banner gets prepended to every header printed when the shell
         instance is called."""
 
         self.banner = banner
 
     def set_exit_msg(self,exit_msg):
         """Sets the global exit_msg.
 
         This exit message gets printed upon exiting every time the embedded
         shell is called. It is None by default. """
 
         self.exit_msg = exit_msg
 
 #-----------------------------------------------------------------------------
 def sigint_handler (signum,stack_frame):
     """Sigint handler for threaded apps.
 
     This is a horrible hack to pass information about SIGINT _without_ using
     exceptions, since I haven't been able to properly manage cross-thread
     exceptions in GTK/WX.  In fact, I don't think it can be done (or at least
     that's my understanding from a c.l.py thread where this was discussed)."""
 
     global KBINT
     
     print '\nKeyboardInterrupt - Press <Enter> to continue.',
     Term.cout.flush()
     # Set global flag so that runsource can know that Ctrl-C was hit
     KBINT = True
 
 class MTInteractiveShell(InteractiveShell):
     """Simple multi-threaded shell."""
 
     # Threading strategy taken from:
     # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
     # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
     # from the pygtk mailing list, to avoid lockups with system calls.
 
     # class attribute to indicate whether the class supports threads or not.
     # Subclasses with thread support should override this as needed.
     isthreaded = True
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None,banner2='',**kw):
         """Similar to the normal InteractiveShell, but with threading control"""
         
         InteractiveShell.__init__(self,name,usage,rc,user_ns,
                                   user_global_ns,banner2)
 
         # Locking control variable
         self.thread_ready = threading.Condition()
 
         # Stuff to do at closing time
         self._kill = False
         on_kill = kw.get('on_kill')
         if on_kill is None:
             on_kill = []
         # Check that all things to kill are callable:
         for t in on_kill:
             if not callable(t):
                 raise TypeError,'on_kill must be a list of callables'
         self.on_kill = on_kill
 
     def runsource(self, source, filename="<input>", symbol="single"):
         """Compile and run some source in the interpreter.
 
         Modified version of code.py's runsource(), to handle threading issues.
         See the original for full docstring details."""
 
         global KBINT
         
         # If Ctrl-C was typed, we reset the flag and return right away
         if KBINT:
             KBINT = False
             return False
         
         try:
             code = self.compile(source, filename, symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
             self.showsyntaxerror(filename)
             return False
 
         if code is None:
             # Case 2
             return True
 
         # Case 3
         # Store code in self, so the execution thread can handle it
         self.thread_ready.acquire()
         self.code_to_run = code
         self.thread_ready.wait()  # Wait until processed in timeout interval
         self.thread_ready.release()
 
         return False
 
     def runcode(self):
         """Execute a code object.
 
         Multithreaded wrapper around IPython's runcode()."""
 
         # lock thread-protected stuff
         self.thread_ready.acquire()
 
         # Install sigint handler
         try:
             signal.signal(signal.SIGINT, sigint_handler)
         except SystemError:
             # This happens under Windows, which seems to have all sorts
             # of problems with signal handling.  Oh well...
             pass
 
         if self._kill:
             print >>Term.cout, 'Closing threads...',
             Term.cout.flush()
             for tokill in self.on_kill:
                 tokill()
             print >>Term.cout, 'Done.'
 
         # Run pending code by calling parent class
         if self.code_to_run is not None:
             self.thread_ready.notify()
             InteractiveShell.runcode(self,self.code_to_run)
             
         # We're done with thread-protected variables
         self.thread_ready.release()
         # This MUST return true for gtk threading to work
         return True
 
     def kill (self):
         """Kill the thread, returning when it has been shut down."""
         self.thread_ready.acquire()
         self._kill = True
         self.thread_ready.release()
 
 class MatplotlibShellBase:
     """Mixin class to provide the necessary modifications to regular IPython
     shell classes for matplotlib support.
 
     Given Python's MRO, this should be used as the FIRST class in the
     inheritance hierarchy, so that it overrides the relevant methods."""
     
     def _matplotlib_config(self,name):
         """Return various items needed to setup the user's shell with matplotlib"""
 
         # Initialize matplotlib to interactive mode always
         import matplotlib
         from matplotlib import backends
         matplotlib.interactive(True)
 
         def use(arg):
             """IPython wrapper for matplotlib's backend switcher.
 
             In interactive use, we can not allow switching to a different
             interactive backend, since thread conflicts will most likely crash
             the python interpreter.  This routine does a safety check first,
             and refuses to perform a dangerous switch.  It still allows
             switching to non-interactive backends."""
 
             if arg in backends.interactive_bk and arg != self.mpl_backend:
                 m=('invalid matplotlib backend switch.\n'
                    'This script attempted to switch to the interactive '
                    'backend: `%s`\n'
                    'Your current choice of interactive backend is: `%s`\n\n'
                    'Switching interactive matplotlib backends at runtime\n'
                    'would crash the python interpreter, '
                    'and IPython has blocked it.\n\n'
                    'You need to either change your choice of matplotlib backend\n'
                    'by editing your .matplotlibrc file, or run this script as a \n'
                    'standalone file from the command line, not using IPython.\n' %
                    (arg,self.mpl_backend) )
                 raise RuntimeError, m
             else:
                 self.mpl_use(arg)
                 self.mpl_use._called = True
         
         self.matplotlib = matplotlib
         self.mpl_backend = matplotlib.rcParams['backend']
 
         # we also need to block switching of interactive backends by use()
         self.mpl_use = matplotlib.use
         self.mpl_use._called = False
         # overwrite the original matplotlib.use with our wrapper
         matplotlib.use = use
 
 
         # This must be imported last in the matplotlib series, after
         # backend/interactivity choices have been made
         try:
             import matplotlib.pylab as pylab
             self.pylab = pylab
             self.pylab_name = 'pylab'
         except ImportError:
             import matplotlib.matlab as matlab            
             self.pylab = matlab
             self.pylab_name = 'matlab'
 
         self.pylab.show._needmain = False
         # We need to detect at runtime whether show() is called by the user.
         # For this, we wrap it into a decorator which adds a 'called' flag.
         self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
 
         # Build a user namespace initialized with matplotlib/matlab features.
         user_ns = {'__name__':'__main__',
                    '__builtins__' : __builtin__ }
 
         # Be careful not to remove the final \n in the code string below, or
         # things will break badly with py22 (I think it's a python bug, 2.3 is
         # OK).
         pname = self.pylab_name # Python can't interpolate dotted var names
         exec ("import matplotlib\n"
               "import matplotlib.%(pname)s as %(pname)s\n"
               "from matplotlib.%(pname)s import *\n" % locals()) in user_ns
         
         # Build matplotlib info banner
         b="""
   Welcome to pylab, a matplotlib-based Python environment.
   For more information, type 'help(pylab)'.
 """
         return user_ns,b
 
     def mplot_exec(self,fname,*where,**kw):
         """Execute a matplotlib script.
 
         This is a call to execfile(), but wrapped in safeties to properly
         handle interactive rendering and backend switching."""
 
         #print '*** Matplotlib runner ***' # dbg
         # turn off rendering until end of script
         isInteractive = self.matplotlib.rcParams['interactive']
         self.matplotlib.interactive(False)
         self.safe_execfile(fname,*where,**kw)
         self.matplotlib.interactive(isInteractive)
         # make rendering call now, if the user tried to do it
         if self.pylab.draw_if_interactive.called:
             self.pylab.draw()
             self.pylab.draw_if_interactive.called = False
                 
         # if a backend switch was performed, reverse it now
         if self.mpl_use._called:
             self.matplotlib.rcParams['backend'] = self.mpl_backend
         
     def magic_run(self,parameter_s=''):
         Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
 
     # Fix the docstring so users see the original as well
     magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
                                     "\n        *** Modified %run for Matplotlib,"
                                     " with proper interactive handling ***")
 
 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
 # and multithreaded.  Note that these are meant for internal use, the IPShell*
 # classes below are the ones meant for public consumption.
 
 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
     """Single-threaded shell with matplotlib support."""
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None,**kw):
         user_ns,b2 = self._matplotlib_config(name)
         InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
                                   banner2=b2,**kw)
 
 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
     """Multi-threaded shell with matplotlib support."""
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None, **kw):
         user_ns,b2 = self._matplotlib_config(name)
         MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
                                     banner2=b2,**kw)
 
 #-----------------------------------------------------------------------------
 # Utility functions for the different GUI enabled IPShell* classes.
 
 def get_tk():
     """Tries to import Tkinter and returns a withdrawn Tkinter root
     window.  If Tkinter is already imported or not available, this
     returns None.  This function calls `hijack_tk` underneath.
     """
     if not USE_TK or sys.modules.has_key('Tkinter'):
         return None
     else:
         try:
             import Tkinter
         except ImportError:
             return None
         else:
             hijack_tk()
             r = Tkinter.Tk()
             r.withdraw()
             return r
 
 def hijack_tk():
     """Modifies Tkinter's mainloop with a dummy so when a module calls
     mainloop, it does not block.
 
     """
     def misc_mainloop(self, n=0):
         pass
     def tkinter_mainloop(n=0):
         pass
     
     import Tkinter
     Tkinter.Misc.mainloop = misc_mainloop
     Tkinter.mainloop = tkinter_mainloop
 
 def update_tk(tk):
     """Updates the Tkinter event loop.  This is typically called from
     the respective WX or GTK mainloops.
     """    
     if tk:
         tk.update()
 
 def hijack_wx():
     """Modifies wxPython's MainLoop with a dummy so user code does not
     block IPython.  The hijacked mainloop function is returned.
     """    
     def dummy_mainloop(*args, **kw):
         pass
     import wxPython
     ver = wxPython.__version__
     orig_mainloop = None
     if ver[:3] >= '2.5':
         import wx
         if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
         elif hasattr(wx, '_core'): core = getattr(wx, '_core')
         else: raise AttributeError('Could not find wx core module')
         orig_mainloop = core.PyApp_MainLoop
         core.PyApp_MainLoop = dummy_mainloop
     elif ver[:3] == '2.4':
         orig_mainloop = wxPython.wxc.wxPyApp_MainLoop
         wxPython.wxc.wxPyApp_MainLoop = dummy_mainloop
     else:
         warn("Unable to find either wxPython version 2.4 or >= 2.5.")
     return orig_mainloop
 
 def hijack_gtk():
     """Modifies pyGTK's mainloop with a dummy so user code does not
     block IPython.  This function returns the original `gtk.mainloop`
     function that has been hijacked.
     """    
     def dummy_mainloop(*args, **kw):
         pass
     import gtk
     if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
     else:                            orig_mainloop = gtk.mainloop
     gtk.mainloop = dummy_mainloop
     gtk.main = dummy_mainloop
     return orig_mainloop
 
 #-----------------------------------------------------------------------------
 # The IPShell* classes below are the ones meant to be run by external code as
 # IPython instances.  Note that unless a specific threading strategy is
 # desired, the factory function start() below should be used instead (it
 # selects the proper threaded class).
 
 class IPShellGTK(threading.Thread):
     """Run a gtk mainloop() in a separate thread.
     
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     GTK timeout callback."""
     
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=1,shell_class=MTInteractiveShell):
 
         import gtk
         
         self.gtk = gtk
         self.gtk_mainloop = hijack_gtk()
 
         # Allows us to use both Tk and GTK.
         self.tk = get_tk()
         
         if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
         else:                            mainquit = self.gtk.mainquit
 
         self.IP = make_IPython(argv,user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,
                                shell_class=shell_class,
                                on_kill=[mainquit])
 
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None 
 
         threading.Thread.__init__(self)
 
     def run(self):
         self.IP.mainloop(self._banner)
         self.IP.kill()
 
     def mainloop(self,sys_exit=0,banner=None):
 
         self._banner = banner
         
         if self.gtk.pygtk_version >= (2,4,0):
             import gobject
             gobject.timeout_add(self.TIMEOUT, self.on_timer)
         else:
             self.gtk.timeout_add(self.TIMEOUT, self.on_timer)
 
         if sys.platform != 'win32':
             try:
                 if self.gtk.gtk_version[0] >= 2:
                     self.gtk.threads_init()
             except AttributeError:
                 pass
             except RuntimeError:
                 error('Your pyGTK likely has not been compiled with '
                       'threading support.\n'
                       'The exception printout is below.\n'
                       'You can either rebuild pyGTK with threads, or '
                       'try using \n'
                       'matplotlib with a different backend (like Tk or WX).\n'
                       'Note that matplotlib will most likely not work in its '
                       'current state!')
                 self.IP.InteractiveTB()
         self.start()
         self.gtk.threads_enter()
         self.gtk_mainloop()
         self.gtk.threads_leave()
         self.join()
 
     def on_timer(self):
         update_tk(self.tk)
         return self.IP.runcode()
         
 
 class IPShellWX(threading.Thread):
     """Run a wx mainloop() in a separate thread.
     
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     GTK timeout callback."""
     
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=1,shell_class=MTInteractiveShell):
 
+        self.IP = make_IPython(argv,user_ns=user_ns,
+                               user_global_ns=user_global_ns,
+                               debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[self.wxexit])
+
+        wantedwxversion=self.IP.rc.wxversion
+        if wantedwxversion!="0":
+            try:
+                import wxversion
+            except ImportError:
+                error('The wxversion module is needed for WX version selection')
+            else:
+                try:
+                    wxversion.select(wantedwxversion)
+                except:
+                    self.IP.InteractiveTB()
+                    error('Requested wxPython version %s could not be loaded' %
+                                                               wantedwxversion)
+
         import wxPython.wx as wx
 
         threading.Thread.__init__(self)
         self.wx = wx
         self.wx_mainloop = hijack_wx()
 
         # Allows us to use both Tk and GTK.
         self.tk = get_tk()
         
-        self.IP = make_IPython(argv,user_ns=user_ns,
-                               user_global_ns=user_global_ns,
-                               debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[self.wxexit])
+        
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None 
 
         self.app = None
 
     def wxexit(self, *args):
         if self.app is not None:
             self.app.agent.timer.Stop()
             self.app.ExitMainLoop()
 
     def run(self):
         self.IP.mainloop(self._banner)
         self.IP.kill()
 
     def mainloop(self,sys_exit=0,banner=None):
 
         self._banner = banner
         
         self.start()
 
         class TimerAgent(self.wx.wxMiniFrame):
             wx = self.wx
             IP = self.IP
             tk = self.tk
             def __init__(self, parent, interval):
                 style = self.wx.wxDEFAULT_FRAME_STYLE | self.wx.wxTINY_CAPTION_HORIZ
                 self.wx.wxMiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
                                              size=(100, 100),style=style)
                 self.Show(False)
                 self.interval = interval
                 self.timerId = self.wx.wxNewId()                                
 
             def StartWork(self):
                 self.timer = self.wx.wxTimer(self, self.timerId)
                 self.wx.EVT_TIMER(self,  self.timerId, self.OnTimer)
                 self.timer.Start(self.interval)
 
             def OnTimer(self, event):
                 update_tk(self.tk)
                 self.IP.runcode()
 
         class App(self.wx.wxApp):
             wx = self.wx
             TIMEOUT = self.TIMEOUT
             def OnInit(self):
                 'Create the main window and insert the custom frame'
                 self.agent = TimerAgent(None, self.TIMEOUT)
                 self.agent.Show(self.wx.false)
                 self.agent.StartWork()
                 return self.wx.true
         
         self.app = App(redirect=False)
         self.wx_mainloop(self.app)
         self.join()
 
 
 class IPShellQt(threading.Thread):
     """Run a Qt event loop in a separate thread.
     
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     Qt timer / slot."""
     
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=0,shell_class=MTInteractiveShell):
         
         import qt
 
         class newQApplication:
             def __init__( self ):
                 self.QApplication = qt.QApplication
                 
             def __call__( *args, **kwargs ):
                 return qt.qApp
 
             def exec_loop( *args, **kwargs ):
                 pass
 
             def __getattr__( self, name ):
                 return getattr( self.QApplication, name )
           
         qt.QApplication = newQApplication()
 
         # Allows us to use both Tk and QT.
         self.tk = get_tk()
 
         self.IP = make_IPython(argv,user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,
                                shell_class=shell_class,
                                on_kill=[qt.qApp.exit])
 
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None 
         
         threading.Thread.__init__(self)
 
     def run(self):
         self.IP.mainloop(self._banner)
         self.IP.kill()
 
     def mainloop(self,sys_exit=0,banner=None):
 
         import qt
 
         self._banner = banner
 
         if qt.QApplication.startingUp():
           a = qt.QApplication.QApplication(sys.argv)
         self.timer = qt.QTimer()
         qt.QObject.connect( self.timer, qt.SIGNAL( 'timeout()' ), self.on_timer )
 
         self.start()
         self.timer.start( self.TIMEOUT, True )
         while True:
             if self.IP._kill: break
             qt.qApp.exec_loop()
         self.join()
 
     def on_timer(self):
         update_tk(self.tk)
         result = self.IP.runcode()
         self.timer.start( self.TIMEOUT, True )
         return result
 
 # A set of matplotlib public IPython shell classes, for single-threaded
 # (Tk* and FLTK* backends) and multithreaded (GTK* and WX* backends) use.
 class IPShellMatplotlib(IPShell):
     """Subclass IPShell with MatplotlibShell as the internal shell.
 
     Single-threaded class, meant for the Tk* and FLTK* backends.
 
     Having this on a separate class simplifies the external driver code."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
                          shell_class=MatplotlibShell)
 
 class IPShellMatplotlibGTK(IPShellGTK):
     """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the GTK* backends."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
                             shell_class=MatplotlibMTShell)
 
 class IPShellMatplotlibWX(IPShellWX):
     """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the WX* backends."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
                            shell_class=MatplotlibMTShell)
 
 class IPShellMatplotlibQt(IPShellQt):
     """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the Qt* backends."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
                            shell_class=MatplotlibMTShell)
 
 #-----------------------------------------------------------------------------
 # Factory functions to actually start the proper thread-aware shell
 
 def _matplotlib_shell_class():
     """Factory function to handle shell class selection for matplotlib.
 
     The proper shell class to use depends on the matplotlib backend, since
     each backend requires a different threading strategy."""
 
     try:
         import matplotlib
     except ImportError:
         error('matplotlib could NOT be imported!  Starting normal IPython.')
         sh_class = IPShell
     else:
         backend = matplotlib.rcParams['backend']
         if backend.startswith('GTK'):
             sh_class = IPShellMatplotlibGTK
         elif backend.startswith('WX'):
             sh_class = IPShellMatplotlibWX
         elif backend.startswith('Qt'):
             sh_class = IPShellMatplotlibQt
         else:
             sh_class = IPShellMatplotlib
     #print 'Using %s with the %s backend.' % (sh_class,backend) # dbg
     return sh_class
 
 # This is the one which should be called by external code.
 def start():
     """Return a running shell instance, dealing with threading options.
 
     This is a factory function which will instantiate the proper IPython shell
     based on the user's threading choice.  Such a selector is needed because
     different GUI toolkits require different thread handling details."""
 
     global USE_TK
     # Crude sys.argv hack to extract the threading options.
     argv = sys.argv
     if len(argv) > 1:
         if len(argv) > 2:
             arg2 = argv[2]
             if arg2.endswith('-tk'):
                 USE_TK = True
         arg1 = argv[1]
         if arg1.endswith('-gthread'):
             shell = IPShellGTK
         elif arg1.endswith( '-qthread' ):
             shell = IPShellQt
         elif arg1.endswith('-wthread'):
             shell = IPShellWX
         elif arg1.endswith('-pylab'):
             shell = _matplotlib_shell_class()
         else:
             shell = IPShell
     else:
         shell = IPShell
     return shell()
 
 # Some aliases for backwards compatibility
 IPythonShell = IPShell
 IPythonShellEmbed = IPShellEmbed
 #************************ End of file <Shell.py> ***************************

IPython/UserConfig/ipythonrc

@@ -1,587 +1,597 b''
 # -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
-# $Id: ipythonrc 990 2006-01-04 06:59:02Z fperez $
+# $Id: ipythonrc 998 2006-01-09 06:57:40Z fperez $
 
 #***************************************************************************
 #
 # Configuration file for IPython -- ipythonrc format
 #
 # The format of this file is simply one of 'key value' lines.
 # Lines containing only whitespace at the beginning and then a # are ignored
 # as comments. But comments can NOT be put on lines with data.
 
 # The meaning and use of each key are explained below.
 
 #---------------------------------------------------------------------------
 # Section: included files
 
 # Put one or more *config* files (with the syntax of this file) you want to
 # include. For keys with a unique value the outermost file has precedence. For
 # keys with multiple values, they all get assembled into a list which then
 # gets loaded by IPython.
 
 # In this file, all lists of things should simply be space-separated.
 
 # This allows you to build hierarchies of files which recursively load
 # lower-level services. If this is your main ~/.ipython/ipythonrc file, you
 # should only keep here basic things you always want available. Then you can
 # include it in every other special-purpose config file you create.
 include 
 
 #---------------------------------------------------------------------------
 # Section: startup setup
 
 # These are mostly things which parallel a command line option of the same
 # name.
 
 # Keys in this section should only appear once. If any key from this section
 # is encountered more than once, the last value remains, all earlier ones get
 # discarded.
 
 
 # Automatic calling of callable objects.  If set to 1 or 2, callable objects
 # are automatically called when invoked at the command line, even if you don't
 # type parentheses.  IPython adds the parentheses for you.  For example:
 
 #In [1]: str 45
 #------> str(45)
 #Out[1]: '45'
 
 # IPython reprints your line with '---->' indicating that it added
 # parentheses.  While this option is very convenient for interactive use, it
 # may occasionally cause problems with objects which have side-effects if
 # called unexpectedly.
 
 # The valid values for autocall are:
 
 # autocall 0 -> disabled (you can toggle it at runtime with the %autocall magic)
 
 # autocall 1 -> active, but do not apply if there are no arguments on the line.
 
 # In this mode, you get:
 
 #In [1]: callable
 #Out[1]: <built-in function callable>
 
 #In [2]: callable 'hello'
 #------> callable('hello')
 #Out[2]: False
 
 # 2 -> Active always.  Even if no arguments are present, the callable object
 # is called:
 
 #In [4]: callable
 #------> callable()
 
 # Note that even with autocall off, you can still use '/' at the start of a
 # line to treat the first argument on the command line as a function and add
 # parentheses to it:
 
 #In [8]: /str 43
 #------> str(43)
 #Out[8]: '43'
 
 autocall 1
 
 # Auto-edit syntax errors.  When you use the %edit magic in ipython to edit
 # source code (see the 'editor' variable below), it is possible that you save
 # a file with syntax errors in it.  If this variable is true, IPython will ask
 # you whether to re-open the editor immediately to correct such an error.
 
 autoedit_syntax 1
 
 # Auto-indent. IPython can recognize lines ending in ':' and indent the next
 # line, while also un-indenting automatically after 'raise' or 'return'.  
 
 # This feature uses the readline library, so it will honor your ~/.inputrc
 # configuration (or whatever file your INPUTRC variable points to).  Adding
 # the following lines to your .inputrc file can make indent/unindenting more
 # convenient (M-i indents, M-u unindents):
 
 #  $if Python
 #  "\M-i": "    "
 #  "\M-u": "\d\d\d\d"
 #  $endif
 
 # The feature is potentially a bit dangerous, because it can cause problems
 # with pasting of indented code (the pasted code gets re-indented on each
 # line).  But it's a huge time-saver when working interactively.  The magic
 # function @autoindent allows you to toggle it on/off at runtime.
 
 autoindent 1
 
 # Auto-magic. This gives you access to all the magic functions without having
 # to prepend them with an @ sign. If you define a variable with the same name
 # as a magic function (say who=1), you will need to access the magic function
 # with @ (@who in this example). However, if later you delete your variable
 # (del who), you'll recover the automagic calling form.
 
 # Considering that many magic functions provide a lot of shell-like
 # functionality, automagic gives you something close to a full Python+system
 # shell environment (and you can extend it further if you want).
 
 automagic 1
 
 # Size of the output cache. After this many entries are stored, the cache will
 # get flushed. Depending on the size of your intermediate calculations, you
 # may have memory problems if you make it too big, since keeping things in the
 # cache prevents Python from reclaiming the memory for old results. Experiment
 # with a value that works well for you.
 
 # If you choose cache_size 0 IPython will revert to python's regular >>>
 # unnumbered prompt. You will still have _, __ and ___ for your last three
 # results, but that will be it.  No dynamic _1, _2, etc. will be created. If
 # you are running on a slow machine or with very limited memory, this may
 # help.
 
 cache_size 1000
 
 # Classic mode: Setting 'classic 1' you lose many of IPython niceties,
 # but that's your choice! Classic 1 -> same as IPython -classic.
 # Note that this is _not_ the normal python interpreter, it's simply
 # IPython emulating most of the classic interpreter's behavior.
 classic 0
 
 # colors - Coloring option for prompts and traceback printouts.
 
 # Currently available schemes: NoColor, Linux, LightBG.
 
 # This option allows coloring the prompts and traceback printouts. This
 # requires a terminal which can properly handle color escape sequences. If you
 # are having problems with this, use the NoColor scheme (uses no color escapes
 # at all).
 
 # The Linux option works well in linux console type environments: dark
 # background with light fonts.
 
 # LightBG is similar to Linux but swaps dark/light colors to be more readable
 # in light background terminals.
 
 # keep uncommented only the one you want:
 colors Linux
 #colors LightBG
 #colors NoColor
 
 ########################
 # Note to Windows users
 #
 # Color and readline support is avaialble to Windows users via Gary Bishop's
 # readline library.  You can find Gary's tools at
 # http://sourceforge.net/projects/uncpythontools.
 # Note that his readline module requires in turn the ctypes library, available
 # at http://starship.python.net/crew/theller/ctypes.
 ########################
 
 # color_info: IPython can display information about objects via a set of
 # functions, and optionally can use colors for this, syntax highlighting
 # source code and various other elements. This information is passed through a
 # pager (it defaults to 'less' if $PAGER is not set). 
 
 # If your pager has problems, try to setting it to properly handle escapes
 # (see the less manpage for detail), or disable this option.  The magic
 # function @color_info allows you to toggle this interactively for testing.
 
 color_info 1
 
 # confirm_exit: set to 1 if you want IPython to confirm when you try to exit
 # with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
 # the magic functions @Exit or @Quit you can force a direct exit, bypassing
 # any confirmation.
 
 confirm_exit 1
 
 # Use deep_reload() as a substitute for reload() by default. deep_reload() is
 # still available as dreload() and appears as a builtin.
 
 deep_reload 0
 
 # Which editor to use with the @edit command. If you leave this at 0, IPython
 # will honor your EDITOR environment variable. Since this editor is invoked on
 # the fly by ipython and is meant for editing small code snippets, you may
 # want to use a small, lightweight editor here.
 
 # For Emacs users, setting up your Emacs server properly as described in the
 # manual is a good idea. An alternative is to use jed, a very light editor
 # with much of the feel of Emacs (though not as powerful for heavy-duty work).
 
 editor 0
 
 # log 1 -> same as ipython -log. This automatically logs to ./ipython.log
 log 0
 
 # Same as ipython -Logfile YourLogfileName. 
 # Don't use with log 1 (use one or the other)
 logfile ''
 
 # banner 0 -> same as ipython -nobanner
 banner 1
 
 # messages 0 -> same as ipython -nomessages
 messages 1
 
 # Automatically call the pdb debugger after every uncaught exception. If you
 # are used to debugging using pdb, this puts you automatically inside of it
 # after any call (either in IPython or in code called by it) which triggers an
 # exception which goes uncaught.
 pdb 0
 
 # Enable the pprint module for printing. pprint tends to give a more readable
 # display (than print) for complex nested data structures.
 pprint 1
 
 # Prompt strings
 
 # Most bash-like escapes can be used to customize IPython's prompts, as well as
 # a few additional ones which are IPython-specific.  All valid prompt escapes
 # are described in detail in the Customization section of the IPython HTML/PDF
 # manual.
 
 # Use \# to represent the current prompt number, and quote them to protect
 # spaces.
 prompt_in1 'In [\#]: '
 
 # \D is replaced by as many dots as there are digits in the
 # current value of \#.
 prompt_in2 '   .\D.: '
 
 prompt_out 'Out[\#]: '
 
 # Select whether to left-pad the output prompts to match the length of the
 # input ones.  This allows you for example to use a simple '>' as an output
 # prompt, and yet have the output line up with the input.  If set to false,
 # the output prompts will be unpadded (flush left).
 prompts_pad_left 1
 
 # quick 1 -> same as ipython -quick
 quick 0
 
 # Use the readline library (1) or not (0). Most users will want this on, but
 # if you experience strange problems with line management (mainly when using
 # IPython inside Emacs buffers) you may try disabling it. Not having it on
 # prevents you from getting command history with the arrow keys, searching and
 # name completion using TAB.
 
 readline 1
 
 # Screen Length: number of lines of your screen. This is used to control
 # printing of very long strings. Strings longer than this number of lines will
 # be paged with the less command instead of directly printed.
 
 # The default value for this is 0, which means IPython will auto-detect your
 # screen size every time it needs to print. If for some reason this isn't
 # working well (it needs curses support), specify it yourself. Otherwise don't
 # change the default.
 
 screen_length 0
 
 # Prompt separators for input and output.
 # Use \n for newline explicitly, without quotes.
 # Use 0 (like at the cmd line) to turn off a given separator.
 
 # The structure of prompt printing is:
 # (SeparateIn)Input....
 # (SeparateOut)Output...
 # (SeparateOut2),   # that is, no newline is printed after Out2
 # By choosing these you can organize your output any way you want.
 
 separate_in \n
 separate_out 0
 separate_out2 0
 
 # 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
 # Simply removes all input/output separators, overriding the choices above.
 nosep 0
 
 # Wildcard searches - IPython has a system for searching names using
 # shell-like wildcards; type %psearch? for details.  This variables sets
 # whether by default such searches should be case sensitive or not.  You can
 # always override the default at the system command line or the IPython
 # prompt.
 
 wildcards_case_sensitive 1
 
 # xmode - Exception reporting mode. 
 
 # Valid modes: Plain, Context and Verbose.
 
 # Plain: similar to python's normal traceback printing.
 
 # Context: prints 5 lines of context source code around each line in the
 # traceback.
 
 # Verbose: similar to Context, but additionally prints the variables currently
 # visible where the exception happened (shortening their strings if too
 # long). This can potentially be very slow, if you happen to have a huge data
 # structure whose string representation is complex to compute. Your computer
 # may appear to freeze for a while with cpu usage at 100%. If this occurs, you
 # can cancel the traceback with Ctrl-C (maybe hitting it more than once).
 
 #xmode Plain
 xmode Context
 #xmode Verbose
 
 # multi_line_specials: if true, allow magics, aliases and shell escapes (via
 # !cmd) to be used in multi-line input (like for loops).  For example, if you
 # have this active, the following is valid in IPython:
 #
 #In [17]: for i in range(3):
 #   ....:     mkdir $i
 #   ....:     !touch $i/hello
 #   ....:     ls -l $i
 
 multi_line_specials 1
 
+# wxversion: request a specific wxPython version (used for -wthread)
+
+# Set this to the value of wxPython you want to use, but note that this
+# feature requires you to have the wxversion Python module to work.  If you
+# don't have the wxversion module (try 'import wxversion' at the prompt to
+# check) or simply want to leave the system to pick up the default, leave this
+# variable at 0.
+
+wxversion 0
+
 #---------------------------------------------------------------------------
 # Section: Readline configuration (readline is not available for MS-Windows)
 
 # This is done via the following options:
 
 # (i) readline_parse_and_bind: this option can appear as many times as you
 # want, each time defining a string to be executed via a
 # readline.parse_and_bind() command. The syntax for valid commands of this
 # kind can be found by reading the documentation for the GNU readline library,
 # as these commands are of the kind which readline accepts in its
 # configuration file.
 
 # The TAB key can be used to complete names at the command line in one of two
 # ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
 # completes as much as possible while 'menu-complete' cycles through all
 # possible completions. Leave the one you prefer uncommented.
 
 readline_parse_and_bind tab: complete
 #readline_parse_and_bind tab: menu-complete
 
 # This binds Control-l to printing the list of all possible completions when
 # there is more than one (what 'complete' does when hitting TAB twice, or at
 # the first TAB if show-all-if-ambiguous is on)
 readline_parse_and_bind "\C-l": possible-completions
 
 # This forces readline to automatically print the above list when tab
 # completion is set to 'complete'. You can still get this list manually by
 # using the key bound to 'possible-completions' (Control-l by default) or by
 # hitting TAB twice. Turning this on makes the printing happen at the first
 # TAB.
 readline_parse_and_bind set show-all-if-ambiguous on
 
 # If you have TAB set to complete names, you can rebind any key (Control-o by
 # default) to insert a true TAB character.
 readline_parse_and_bind "\C-o": tab-insert
 
 # These commands allow you to indent/unindent easily, with the 4-space
 # convention of the Python coding standards.  Since IPython's internal
 # auto-indent system also uses 4 spaces, you should not change the number of
 # spaces in the code below.
 readline_parse_and_bind "\M-i": "    "
 readline_parse_and_bind "\M-o": "\d\d\d\d"
 readline_parse_and_bind "\M-I": "\d\d\d\d"
 
 # Bindings for incremental searches in the history. These searches use the
 # string typed so far on the command line and search anything in the previous
 # input history containing them.
 readline_parse_and_bind "\C-r": reverse-search-history
 readline_parse_and_bind "\C-s": forward-search-history
 
 # Bindings for completing the current line in the history of previous
 # commands. This allows you to recall any previous command by typing its first
 # few letters and hitting Control-p, bypassing all intermediate commands which
 # may be in the history (much faster than hitting up-arrow 50 times!)
 readline_parse_and_bind "\C-p": history-search-backward
 readline_parse_and_bind "\C-n": history-search-forward
 
 # I also like to have the same functionality on the plain arrow keys. If you'd
 # rather have the arrows use all the history (and not just match what you've
 # typed so far), comment out or delete the next two lines.
 readline_parse_and_bind "\e[A": history-search-backward
 readline_parse_and_bind "\e[B": history-search-forward
 
 # These are typically on by default under *nix, but not win32.
 readline_parse_and_bind "\C-k": kill-line
 readline_parse_and_bind "\C-u": unix-line-discard
 
 # (ii) readline_remove_delims: a string of characters to be removed from the
 # default word-delimiters list used by readline, so that completions may be
 # performed on strings which contain them.
 
 readline_remove_delims -/~
 
 # (iii) readline_merge_completions: whether to merge the result of all
 # possible completions or not.  If true, IPython will complete filenames,
 # python names and aliases and return all possible completions.  If you set it
 # to false, each completer is used at a time, and only if it doesn't return
 # any completions is the next one used.
 
 # The default order is: [python_matches, file_matches, alias_matches]
 
 readline_merge_completions 1
 
 # (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
 # will complete all attributes of an object, including all the special methods
 # whose names start with single or double underscores (like __getitem__ or
 # __class__).
 
 # This variable allows you to control this completion behavior:
 
 # readline_omit__names 1 -> completion will omit showing any names starting
 # with two __, but it will still show names starting with one _.
 
 # readline_omit__names 2 -> completion will omit all names beginning with one
 # _ (which obviously means filtering out the double __ ones).
 
 # Even when this option is set, you can still see those names by explicitly
 # typing a _ after the period and hitting <tab>: 'name._<tab>' will always
 # complete attribute names starting with '_'.
 
 # This option is off by default so that new users see all attributes of any
 # objects they are dealing with.
 
 readline_omit__names 0
 
 #---------------------------------------------------------------------------
 # Section: modules to be loaded with 'import ...'
 
 # List, separated by spaces, the names of the modules you want to import
 
 # Example:
 # import_mod sys os
 # will produce internally the statements
 # import sys
 # import os
 
 # Each import is executed in its own try/except block, so if one module
 # fails to load the others will still be ok.
 
 import_mod 
 
 #---------------------------------------------------------------------------
 # Section: modules to import some functions from: 'from ... import ...'
 
 # List, one per line, the modules for which you want only to import some
 # functions. Give the module name first and then the name of functions to be
 # imported from that module.
 
 # Example:
 
 # import_some IPython.genutils timing timings
 # will produce internally the statement
 # from IPython.genutils import timing, timings
 
 # timing() and timings() are two IPython utilities for timing the execution of
 # your own functions, which you may find useful.  Just commment out the above
 # line if you want to test them.
 
 # If you have more than one modules_some line, each gets its own try/except
 # block (like modules, see above).
 
 import_some 
 
 #---------------------------------------------------------------------------
 # Section: modules to import all from : 'from ... import *'
 
 # List (same syntax as import_mod above) those modules for which you want to
 # import all functions. Remember, this is a potentially dangerous thing to do,
 # since it is very easy to overwrite names of things you need. Use with
 # caution.
 
 # Example:
 # import_all sys os
 # will produce internally the statements
 # from sys import *
 # from os import *
 
 # As before, each will be called in a separate try/except block.
 
 import_all 
 
 #---------------------------------------------------------------------------
 # Section: Python code to execute.
 
 # Put here code to be explicitly executed (keep it simple!)
 # Put one line of python code per line. All whitespace is removed (this is a
 # feature, not a bug), so don't get fancy building loops here.
 # This is just for quick convenient creation of things you want available.
 
 # Example:
 # execute x = 1
 # execute print 'hello world'; y = z = 'a'
 # will produce internally
 # x = 1
 # print 'hello world'; y = z = 'a'
 # and each *line* (not each statement, we don't do python syntax parsing) is
 # executed in its own try/except block.
 
 execute 
 
 # Note for the adventurous: you can use this to define your own names for the
 # magic functions, by playing some namespace tricks:
 
 # execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
 
 # defines @pf as a new name for @profile.
 
 #---------------------------------------------------------------------------
 # Section: Pyhton files to load and execute.
 
 # Put here the full names of files you want executed with execfile(file).  If
 # you want complicated initialization, just write whatever you want in a
 # regular python file and load it from here.
 
 # Filenames defined here (which *must* include the extension) are searched for
 # through all of sys.path. Since IPython adds your .ipython directory to
 # sys.path, they can also be placed in your .ipython dir and will be
 # found. Otherwise (if you want to execute things not in .ipyton nor in
 # sys.path) give a full path (you can use ~, it gets expanded)
 
 # Example:
 # execfile file1.py ~/file2.py
 # will generate
 # execfile('file1.py')
 # execfile('_path_to_your_home/file2.py')
 
 # As before, each file gets its own try/except block.
 
 execfile
 
 # If you are feeling adventurous, you can even add functionality to IPython
 # through here. IPython works through a global variable called __ip which
 # exists at the time when these files are read. If you know what you are doing
 # (read the source) you can add functions to __ip in files loaded here. 
 
 # The file example-magic.py contains a simple but correct example. Try it:
 
 # execfile example-magic.py
 
 # Look at the examples in IPython/iplib.py for more details on how these magic
 # functions need to process their arguments.
 
 #---------------------------------------------------------------------------
 # Section: aliases for system shell commands
 
 # Here you can define your own names for system commands. The syntax is
 # similar to that of the builtin @alias function:
 
 # alias alias_name command_string
 
 # The resulting aliases are auto-generated magic functions (hence usable as
 # @alias_name)
 
 # For example:
 
 # alias myls ls -la
 
 # will define 'myls' as an alias for executing the system command 'ls -la'.
 # This allows you to customize IPython's environment to have the same aliases
 # you are accustomed to from your own shell.
 
 # You can also define aliases with parameters using %s specifiers (one per
 # parameter):
 
 # alias parts echo first %s second %s
 
 # will give you in IPython:
 # >>> @parts A B
 # first A second B
 
 # Use one 'alias' statement per alias you wish to define.
 
 # alias 
 
 #************************* end of file <ipythonrc> ************************

IPython/__init__.py

@@ -1,64 +1,64 b''
 # -*- coding: utf-8 -*-
 """
 IPython -- An enhanced Interactive Python
 
 One of Python's nicest features is its interactive interpreter. This allows
 very fast testing of ideas without the overhead of creating test files as is
 typical in most programming languages. However, the interpreter supplied with
 the standard Python distribution is fairly primitive (and IDLE isn't really
 much better).
 
 IPython tries to:
 
   i - provide an efficient environment for interactive work in Python
   programming. It tries to address what we see as shortcomings of the standard
   Python prompt, and adds many features to make interactive work much more
   efficient.
 
   ii - offer a flexible framework so that it can be used as the base
   environment for other projects and problems where Python can be the
   underlying language. Specifically scientific environments like Mathematica,
   IDL and Mathcad inspired its design, but similar ideas can be useful in many
   fields. Python is a fabulous language for implementing this kind of system
   (due to its dynamic and introspective features), and with suitable libraries
   entire systems could be built leveraging Python's power.
 
   iii - serve as an embeddable, ready to go interpreter for your own programs.
 
 IPython requires Python 2.2 or newer.
 
-$Id: __init__.py 775 2005-09-01 20:24:59Z fperez $"""
+$Id: __init__.py 998 2006-01-09 06:57:40Z fperez $"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2004 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.
 #*****************************************************************************
 
 # Enforce proper version requirements
 import sys
-if sys.version[0:3] < '2.2':
-    raise ImportError, 'Python Version 2.2 or above is required.'
+if sys.version[0:3] < '2.3':
+    raise ImportError, 'Python Version 2.3 or above is required.'
         
 # Define what gets imported with a 'from IPython import *'
 __all__ = ['deep_reload','genutils','ultraTB','DPyGetOpt','Itpl','hooks',
            'ConfigLoader','OutputTrap','Release','Struct','Shell']
 
 # Load __all__ in IPython namespace so that a simple 'import IPython' gives
 # access to them via IPython.<name>
 glob,loc = globals(),locals()
 for name in __all__:
     __import__(name,glob,loc,[])
 
 # Release data
 from IPython import Release # do it explicitly so pydoc can see it - pydoc bug
 __author__   = '%s <%s>\n%s <%s>\n%s <%s>' % \
                ( Release.authors['Fernando'] + Release.authors['Janko'] + \
                  Release.authors['Nathan'] )
 __license__  = Release.license
 __version__  = Release.version
 __revision__ = Release.revision
 
 # Namespace cleanup
 del name,glob,loc

IPython/ipmaker.py

@@ -1,701 +1,703 b''
 # -*- coding: utf-8 -*-
 """
 IPython -- An enhanced Interactive Python
 
 Requires Python 2.1 or better.
 
 This file contains the main make_IPython() starter function.
 
-$Id: ipmaker.py 994 2006-01-08 08:29:44Z fperez $"""
+$Id: ipmaker.py 998 2006-01-09 06:57:40Z fperez $"""
 
 #*****************************************************************************
 #       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.
 #*****************************************************************************
 
 from IPython import Release
 __author__  = '%s <%s>' % Release.authors['Fernando']
 __license__ = Release.license
 __version__ = Release.version
 
 credits._Printer__data = """
 Python: %s
 
 IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
 See http://ipython.scipy.org for more information.""" \
 % credits._Printer__data
 
 copyright._Printer__data += """
 
 Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
 All Rights Reserved."""
 
 #****************************************************************************
 # Required modules
 
 # From the standard library
 import __main__
 import __builtin__
 import os
 import re
 import sys
 import types
 from pprint import pprint,pformat
 
 # Our own
 from IPython import DPyGetOpt
 from IPython.Struct import Struct
 from IPython.OutputTrap import OutputTrap
 from IPython.ConfigLoader import ConfigLoader
 from IPython.iplib import InteractiveShell
 from IPython.usage import cmd_line_usage,interactive_usage
 from IPython.genutils import *
 
 #-----------------------------------------------------------------------------
 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
                  rc_override=None,shell_class=InteractiveShell,
                  embedded=False,**kw):
     """This is a dump of IPython into a single function.
 
     Later it will have to be broken up in a sensible manner.
 
     Arguments:
 
     - argv: a list similar to sys.argv[1:].  It should NOT contain the desired
     script name, b/c DPyGetOpt strips the first argument only for the real
     sys.argv.
 
     - user_ns: a dict to be used as the user's namespace."""
 
     #----------------------------------------------------------------------
     # Defaults and initialization
     
     # For developer debugging, deactivates crash handler and uses pdb.
     DEVDEBUG = False
 
     if argv is None:
         argv = sys.argv
 
     # __IP is the main global that lives throughout and represents the whole
     # application. If the user redefines it, all bets are off as to what
     # happens.
 
     # __IP is the name of he global which the caller will have accessible as
     # __IP.name. We set its name via the first parameter passed to
     # InteractiveShell:
 
     IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
                      embedded=embedded,**kw)
 
     # Put 'help' in the user namespace
     from site import _Helper
     IP.user_ns['help'] = _Helper()
 
 
     if DEVDEBUG:
         # For developer debugging only (global flag)
         from IPython import ultraTB
         sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
 
     IP.BANNER_PARTS = ['Python %s\n'
                          'Type "copyright", "credits" or "license" '
                          'for more information.\n'
                          % (sys.version.split('\n')[0],),
                          "IPython %s -- An enhanced Interactive Python."
                          % (__version__,),
 """?       -> Introduction to IPython's features.
 %magic  -> Information about IPython's 'magic' % functions.
 help    -> Python's own help system.
 object? -> Details about 'object'. ?object also works, ?? prints more.
 """ ]
 
     IP.usage = interactive_usage
 
     # Platform-dependent suffix and directory names.  We use _ipython instead
     # of .ipython under win32 b/c there's software that breaks with .named
     # directories on that platform.
     if os.name == 'posix':
         rc_suffix = ''
         ipdir_def = '.ipython'
     else:
         rc_suffix = '.ini'
         ipdir_def = '_ipython'
 
     # default directory for configuration
     ipythondir = os.path.abspath(os.environ.get('IPYTHONDIR',
                                  os.path.join(IP.home_dir,ipdir_def)))
 
     # we need the directory where IPython itself is installed
     import IPython
     IPython_dir = os.path.dirname(IPython.__file__)
     del IPython
     
     #-------------------------------------------------------------------------
     # Command line handling
 
     # Valid command line options (uses DPyGetOpt syntax, like Perl's
     # GetOpt::Long)
 
     # Any key not listed here gets deleted even if in the file (like session
     # or profile). That's deliberate, to maintain the rc namespace clean.
 
     # Each set of options appears twice: under _conv only the names are
     # listed, indicating which type they must be converted to when reading the
     # ipythonrc file. And under DPyGetOpt they are listed with the regular
     # DPyGetOpt syntax (=s,=i,:f,etc).
 
     # Make sure there's a space before each end of line (they get auto-joined!)
     cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i '
                     'c=s classic|cl color_info! colors=s confirm_exit! '
                     'debug! deep_reload! editor=s log|l messages! nosep pdb! '
                     'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
                     'quick screen_length|sl=i prompts_pad_left=i '
                     'logfile|lf=s logplay|lp=s profile|p=s '
                     'readline! readline_merge_completions! '
                     'readline_omit__names! '
                     'rcfile=s separate_in|si=s separate_out|so=s '
                     'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
                     'magic_docstrings system_verbose! '
                     'multi_line_specials! '
+                    'wxversion=s '
                     'autoedit_syntax!')
 
     # Options that can *only* appear at the cmd line (not in rcfiles).
     
     # The "ignore" option is a kludge so that Emacs buffers don't crash, since
     # the 'C-c !' command in emacs automatically appends a -i option at the end.
     cmdline_only = ('help ignore|i ipythondir=s Version upgrade '
                     'gthread! qthread! wthread! pylab! tk!')
 
     # Build the actual name list to be used by DPyGetOpt
     opts_names = qw(cmdline_opts) + qw(cmdline_only)
 
     # Set sensible command line defaults.
     # This should have everything from  cmdline_opts and cmdline_only
     opts_def = Struct(autocall = 1,
                       autoedit_syntax = 1,
                       autoindent=0,
                       automagic = 1,
                       banner = 1,
                       cache_size = 1000,
                       c = '',
                       classic = 0,
                       colors = 'NoColor',
                       color_info = 0,
                       confirm_exit = 1,
                       debug = 0,
                       deep_reload = 0,
                       editor = '0',
                       help = 0,
                       ignore = 0,
                       ipythondir = ipythondir,
                       log = 0,
                       logfile = '',
                       logplay = '',
                       multi_line_specials = 1,
                       messages = 1,
                       nosep = 0,
                       pdb = 0,
                       pprint = 0,
                       profile = '',
                       prompt_in1 = 'In [\\#]: ',
                       prompt_in2 = '   .\\D.: ',
                       prompt_out = 'Out[\\#]: ',
                       prompts_pad_left = 1,
                       quick = 0,
                       readline = 1,
                       readline_merge_completions = 1,
                       readline_omit__names = 0,
                       rcfile = 'ipythonrc' + rc_suffix,
                       screen_length = 0,
                       separate_in = '\n',
                       separate_out = '\n',
                       separate_out2 = '',
                       system_verbose = 0,
                       gthread = 0,
                       qthread = 0,
                       wthread = 0,
                       pylab = 0,
                       tk = 0,
                       upgrade = 0,
                       Version = 0,
                       xmode = 'Verbose',
                       wildcards_case_sensitive = 1,
+                      wxversion = '0',
                       magic_docstrings = 0,  # undocumented, for doc generation
                       )
     
     # Things that will *only* appear in rcfiles (not at the command line).
     # Make sure there's a space before each end of line (they get auto-joined!)
     rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
                     qw_lol: 'import_some ',
                     # for things with embedded whitespace:
                     list_strings:'execute alias readline_parse_and_bind ',
                     # Regular strings need no conversion:
                     None:'readline_remove_delims ',
                     }
     # Default values for these
     rc_def = Struct(include = [],
                     import_mod = [], 
                     import_all = [],
                     import_some = [[]],
                     execute = [],
                     execfile = [],
                     alias = [],
                     readline_parse_and_bind = [],
                     readline_remove_delims = '',
                     )
 
     # Build the type conversion dictionary from the above tables:
     typeconv = rcfile_opts.copy()
     typeconv.update(optstr2types(cmdline_opts))
 
     # FIXME: the None key appears in both, put that back together by hand. Ugly!
     typeconv[None] += ' ' + rcfile_opts[None]
 
     # Remove quotes at ends of all strings (used to protect spaces)
     typeconv[unquote_ends] = typeconv[None]
     del typeconv[None]
 
     # Build the list we'll use to make all config decisions with defaults:
     opts_all = opts_def.copy()
     opts_all.update(rc_def)
 
     # Build conflict resolver for recursive loading of config files:
     # - preserve means the outermost file maintains the value, it is not
     # overwritten if an included file has the same key.
     # - add_flip applies + to the two values, so it better make sense to add
     # those types of keys. But it flips them first so that things loaded
     # deeper in the inclusion chain have lower precedence.
     conflict = {'preserve': ' '.join([ typeconv[int],
                                        typeconv[unquote_ends] ]),
                 'add_flip': ' '.join([ typeconv[qwflat],
                                        typeconv[qw_lol],
                                        typeconv[list_strings] ])
                 }
 
     # Now actually process the command line
     getopt = DPyGetOpt.DPyGetOpt()
     getopt.setIgnoreCase(0)
 
     getopt.parseConfiguration(opts_names)
 
     try:
         getopt.processArguments(argv)
     except:
         print cmd_line_usage
         warn('\nError in Arguments: ' + `sys.exc_value`)
         sys.exit(1)
 
     # convert the options dict to a struct for much lighter syntax later
     opts = Struct(getopt.optionValues)
     args = getopt.freeValues
 
     # this is the struct (which has default values at this point) with which
     # we make all decisions:
     opts_all.update(opts)
 
     # Options that force an immediate exit
     if opts_all.help:
         page(cmd_line_usage)
         sys.exit()
 
     if opts_all.Version:
         print __version__
         sys.exit()
 
     if opts_all.magic_docstrings:
         IP.magic_magic('-latex')
         sys.exit()
 
     # Create user config directory if it doesn't exist. This must be done
     # *after* getting the cmd line options.
     if not os.path.isdir(opts_all.ipythondir):
         IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
 
     # upgrade user config files while preserving a copy of the originals
     if opts_all.upgrade:
         IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
 
     # check mutually exclusive options in the *original* command line
     mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
                      qw('classic profile'),qw('classic rcfile')])
 
     #---------------------------------------------------------------------------
     # Log replay
     
     # if -logplay, we need to 'become' the other session. That basically means
     # replacing the current command line environment with that of the old
     # session and moving on.
 
     # this is needed so that later we know we're in session reload mode, as
     # opts_all will get overwritten:
     load_logplay = 0
 
     if opts_all.logplay:
         load_logplay = opts_all.logplay 
         opts_debug_save = opts_all.debug
         try:
             logplay = open(opts_all.logplay)
         except IOError:
             if opts_all.debug: IP.InteractiveTB()
             warn('Could not open logplay file '+`opts_all.logplay`)
             # restore state as if nothing had happened and move on, but make
             # sure that later we don't try to actually load the session file
             logplay = None
             load_logplay = 0
             del opts_all.logplay
         else:
             try: 
                 logplay.readline()
                 logplay.readline();
                 # this reloads that session's command line
                 cmd = logplay.readline()[6:] 
                 exec cmd
                 # restore the true debug flag given so that the process of
                 # session loading itself can be monitored.
                 opts.debug = opts_debug_save
                 # save the logplay flag so later we don't overwrite the log
                 opts.logplay = load_logplay
                 # now we must update our own structure with defaults
                 opts_all.update(opts)
                 # now load args
                 cmd = logplay.readline()[6:] 
                 exec cmd
                 logplay.close()
             except:
                 logplay.close()
                 if opts_all.debug: IP.InteractiveTB()
                 warn("Logplay file lacking full configuration information.\n"
                      "I'll try to read it, but some things may not work.")
 
     #-------------------------------------------------------------------------
     # set up output traps: catch all output from files, being run, modules
     # loaded, etc. Then give it to the user in a clean form at the end.
     
     msg_out = 'Output messages. '
     msg_err = 'Error messages. '
     msg_sep = '\n'
     msg = Struct(config    = OutputTrap('Configuration Loader',msg_out,
                                         msg_err,msg_sep,debug,
                                         quiet_out=1),
                  user_exec = OutputTrap('User File Execution',msg_out,
                                         msg_err,msg_sep,debug),
                  logplay   = OutputTrap('Log Loader',msg_out,
                                         msg_err,msg_sep,debug),
                  summary = ''
                  )
 
     #-------------------------------------------------------------------------
     # Process user ipythonrc-type configuration files
 
     # turn on output trapping and log to msg.config
     # remember that with debug on, trapping is actually disabled
     msg.config.trap_all()
 
     # look for rcfile in current or default directory
     try:
         opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
     except IOError:
         if opts_all.debug:  IP.InteractiveTB()
         warn('Configuration file %s not found. Ignoring request.'
              % (opts_all.rcfile) )
 
     # 'profiles' are a shorthand notation for config filenames
     if opts_all.profile:
         try:
             opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
                                        + rc_suffix,
                                        opts_all.ipythondir)
         except IOError:
            if opts_all.debug:  IP.InteractiveTB()
            opts.profile = ''  # remove profile from options if invalid
            warn('Profile configuration file %s not found. Ignoring request.'
                 % (opts_all.profile) )
 
     # load the config file
     rcfiledata = None
     if opts_all.quick:
         print 'Launching IPython in quick mode. No config file read.'
     elif opts_all.classic:
         print 'Launching IPython in classic mode. No config file read.'
     elif opts_all.rcfile:
         try:
             cfg_loader = ConfigLoader(conflict)
             rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
                                          'include',opts_all.ipythondir,
                                          purge = 1,
                                          unique = conflict['preserve'])
         except:
             IP.InteractiveTB()
             warn('Problems loading configuration file '+
                  `opts_all.rcfile`+
                  '\nStarting with default -bare bones- configuration.')
     else:
         warn('No valid configuration file found in either currrent directory\n'+
              'or in the IPython config. directory: '+`opts_all.ipythondir`+
              '\nProceeding with internal defaults.')
 
     #------------------------------------------------------------------------
     # Set exception handlers in mode requested by user.
     otrap = OutputTrap(trap_out=1)  # trap messages from magic_xmode
     IP.magic_xmode(opts_all.xmode)
     otrap.release_out()
 
     #------------------------------------------------------------------------
     # Execute user config
 
     # Create a valid config structure with the right precedence order:
     # defaults < rcfile < command line.  This needs to be in the instance, so
     # that method calls below that rely on it find it.
     IP.rc = rc_def.copy()
 
     # Work with a local alias inside this routine to avoid unnecessary
     # attribute lookups.
     IP_rc = IP.rc
     
     IP_rc.update(opts_def)
     if rcfiledata:
         # now we can update 
         IP_rc.update(rcfiledata)
     IP_rc.update(opts)
     IP_rc.update(rc_override)
 
     # Store the original cmd line for reference:
     IP_rc.opts = opts
     IP_rc.args = args
 
     # create a *runtime* Struct like rc for holding parameters which may be
     # created and/or modified by runtime user extensions.
     IP.runtime_rc = Struct()
 
     # from this point on, all config should be handled through IP_rc,
     # opts* shouldn't be used anymore.
 
     # add personal .ipython dir to sys.path so that users can put things in
     # there for customization
     sys.path.append(IP_rc.ipythondir)
     sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
     
     # update IP_rc with some special things that need manual
     # tweaks. Basically options which affect other options. I guess this
     # should just be written so that options are fully orthogonal and we
     # wouldn't worry about this stuff!
 
     if IP_rc.classic:
         IP_rc.quick = 1
         IP_rc.cache_size = 0
         IP_rc.pprint = 0
         IP_rc.prompt_in1 = '>>> '
         IP_rc.prompt_in2 = '... '
         IP_rc.prompt_out = ''
         IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
         IP_rc.colors = 'NoColor'
         IP_rc.xmode = 'Plain'
 
     # configure readline
     # Define the history file for saving commands in between sessions
     if IP_rc.profile:
         histfname = 'history-%s' % IP_rc.profile
     else:
         histfname = 'history'
     IP.histfile = os.path.join(opts_all.ipythondir,histfname)
 
     # update exception handlers with rc file status
     otrap.trap_out()  # I don't want these messages ever.
     IP.magic_xmode(IP_rc.xmode)
     otrap.release_out()
 
     # activate logging if requested and not reloading a log
     if IP_rc.logplay:
         IP.magic_logstart(IP_rc.logplay + ' append')
     elif  IP_rc.logfile:
         IP.magic_logstart(IP_rc.logfile)
     elif IP_rc.log:
         IP.magic_logstart()
 
     # find user editor so that it we don't have to look it up constantly
     if IP_rc.editor.strip()=='0':
         try:
             ed = os.environ['EDITOR']
         except KeyError:
             if os.name == 'posix':
                 ed = 'vi'  # the only one guaranteed to be there!
             else:
                 ed = 'notepad' # same in Windows!
         IP_rc.editor = ed
 
     # Keep track of whether this is an embedded instance or not (useful for
     # post-mortems).
     IP_rc.embedded = IP.embedded
 
     # Recursive reload
     try:
         from IPython import deep_reload
         if IP_rc.deep_reload:
             __builtin__.reload = deep_reload.reload
         else:
             __builtin__.dreload = deep_reload.reload
         del deep_reload
     except ImportError:
         pass
 
     # Save the current state of our namespace so that the interactive shell
     # can later know which variables have been created by us from config files
     # and loading. This way, loading a file (in any way) is treated just like
     # defining things on the command line, and %who works as expected.
 
     # DON'T do anything that affects the namespace beyond this point!
     IP.internal_ns.update(__main__.__dict__)
 
     #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
 
     # Now run through the different sections of the users's config
     if IP_rc.debug:
         print 'Trying to execute the following configuration structure:'
         print '(Things listed first are deeper in the inclusion tree and get'
         print 'loaded first).\n'
         pprint(IP_rc.__dict__)
         
     for mod in IP_rc.import_mod:
         try:
             exec 'import '+mod in IP.user_ns
         except :
             IP.InteractiveTB()
             import_fail_info(mod)
 
     for mod_fn in IP_rc.import_some:
         if mod_fn == []: break
         mod,fn = mod_fn[0],','.join(mod_fn[1:])
         try:
             exec 'from '+mod+' import '+fn in IP.user_ns
         except :
             IP.InteractiveTB()
             import_fail_info(mod,fn)
 
     for mod in IP_rc.import_all:
         try:
             exec 'from '+mod+' import *' in IP.user_ns
         except :
             IP.InteractiveTB()
             import_fail_info(mod)
 
     for code in IP_rc.execute:
         try:
             exec code in IP.user_ns
         except:
             IP.InteractiveTB()
             warn('Failure executing code: ' + `code`)
 
     # Execute the files the user wants in ipythonrc
     for file in IP_rc.execfile:
         try:
             file = filefind(file,sys.path+[IPython_dir])
         except IOError:
             warn(itpl('File $file not found. Skipping it.'))
         else:
             IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
 
     # release stdout and stderr and save config log into a global summary
     msg.config.release_all()
     if IP_rc.messages:
         msg.summary += msg.config.summary_all()
 
     #------------------------------------------------------------------------
     # Setup interactive session
 
     # Now we should be fully configured. We can then execute files or load
     # things only needed for interactive use. Then we'll open the shell.
 
     # Take a snapshot of the user namespace before opening the shell. That way
     # we'll be able to identify which things were interactively defined and
     # which were defined through config files.
     IP.user_config_ns = IP.user_ns.copy()
 
     # Force reading a file as if it were a session log. Slower but safer.
     if load_logplay:
         print 'Replaying log...'
         try:
             if IP_rc.debug:
                 logplay_quiet = 0
             else:
                  logplay_quiet = 1
 
             msg.logplay.trap_all()
             IP.safe_execfile(load_logplay,IP.user_ns,
                              islog = 1, quiet = logplay_quiet)
             msg.logplay.release_all()
             if IP_rc.messages:
                 msg.summary += msg.logplay.summary_all()
         except:
             warn('Problems replaying logfile %s.' % load_logplay)
             IP.InteractiveTB()
 
     # Load remaining files in command line
     msg.user_exec.trap_all()
 
     # Do NOT execute files named in the command line as scripts to be loaded
     # by embedded instances.  Doing so has the potential for an infinite
     # recursion if there are exceptions thrown in the process.
 
     # XXX FIXME: the execution of user files should be moved out to after
     # ipython is fully initialized, just as if they were run via %run at the
     # ipython prompt.  This would also give them the benefit of ipython's
     # nice tracebacks.
     
     if not embedded and IP_rc.args:
         name_save = IP.user_ns['__name__']
         IP.user_ns['__name__'] = '__main__'
         try:
             # Set our own excepthook in case the user code tries to call it
             # directly. This prevents triggering the IPython crash handler.
             old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
             for run in args:
                 IP.safe_execfile(run,IP.user_ns)
         finally:
             # Reset our crash handler in place
             sys.excepthook = old_excepthook
             
         IP.user_ns['__name__'] = name_save
         
     msg.user_exec.release_all()
     if IP_rc.messages:
         msg.summary += msg.user_exec.summary_all()
 
     # since we can't specify a null string on the cmd line, 0 is the equivalent:
     if IP_rc.nosep:
         IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
     if IP_rc.separate_in == '0': IP_rc.separate_in = ''
     if IP_rc.separate_out == '0': IP_rc.separate_out = ''
     if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
     IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
     IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
     IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
 
     # Determine how many lines at the bottom of the screen are needed for
     # showing prompts, so we can know wheter long strings are to be printed or
     # paged:
     num_lines_bot = IP_rc.separate_in.count('\n')+1
     IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
 
     # configure startup banner
     if IP_rc.c:  # regular python doesn't print the banner with -c
         IP_rc.banner = 0
     if IP_rc.banner:
         BANN_P = IP.BANNER_PARTS
     else:
         BANN_P = []
 
     if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
 
     # add message log (possibly empty)
     if msg.summary: BANN_P.append(msg.summary)
     # Final banner is a string
     IP.BANNER = '\n'.join(BANN_P)
 
     # Finalize the IPython instance.  This assumes the rc structure is fully
     # in place.
     IP.post_config_initialization()
 
     return IP
 #************************ end of file <ipmaker.py> **************************

IPython/usage.py

@@ -1,589 +1,599 b''
 # -*- coding: utf-8 -*-
 #*****************************************************************************
 #       Copyright (C) 2001-2004 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.
 #*****************************************************************************
 
-# $Id: usage.py 990 2006-01-04 06:59:02Z fperez $
+# $Id: usage.py 998 2006-01-09 06:57:40Z fperez $
 
 from IPython import Release
 __author__  = '%s <%s>' % Release.authors['Fernando']
 __license__ = Release.license
 __version__ = Release.version
 
 __doc__ = """
 IPython -- An enhanced Interactive Python
 =========================================
 
 A Python shell with automatic history (input and output), dynamic object
 introspection, easier configuration, command completion, access to the system
 shell and more.
 
 IPython can also be embedded in running programs. See EMBEDDING below.
 
 
 USAGE
        ipython [options] files
 
        If invoked with no options, it executes all the files listed in
        sequence and drops you into the interpreter while still acknowledging
        any options you may have set in your ipythonrc file. This behavior is
        different from standard Python, which when called as python -i will
        only execute one file and will ignore your configuration setup.
 
        Please note that some of the configuration options are not available at
        the command line, simply because they are not practical here. Look into
        your ipythonrc configuration file for details on those. This file
        typically installed in the $HOME/.ipython directory.
 
        For Windows users, $HOME resolves to C:\\Documents and
        Settings\\YourUserName in most instances, and _ipython is used instead
        of .ipython, since some Win32 programs have problems with dotted names
        in directories.
 
        In the rest of this text, we will refer to this directory as
        IPYTHONDIR.
 
 
 SPECIAL THREADING OPTIONS
        The following special options are ONLY valid at the  beginning  of  the
        command line, and not later.  This is because they control the initial-
        ization of ipython itself, before the normal option-handling  mechanism
        is active.
 
        -gthread, -qthread, -wthread, -pylab
 
               Only ONE of these can be given, and it can only be given as the
               first option passed to IPython (it will have no effect in any
               other position).  They provide threading support for the GTK, QT
               and WXWidgets toolkits, and for the matplotlib library.
 
               With any of the first three options, IPython starts running a
               separate thread for the graphical toolkit's operation, so that
               you can open and control graphical elements from within an
               IPython command line, without blocking.  All three provide
               essentially the same functionality, respectively for GTK, QT and
               WXWidgets (via their Python interfaces).
 
+              Note that with -wthread, you can additionally use the -wxversion
+              option to request a specific version of wx to be used.  This
+              requires that you have the 'wxversion' Python module installed,
+              which is part of recent wxPython distributions.
+
               If -pylab is given, IPython loads special support for the mat-
               plotlib library (http://matplotlib.sourceforge.net), allowing
               interactive usage of any of its backends as defined in the
               user's .matplotlibrc file.  It automatically activates GTK, QT
               or WX threading for IPyhton if the choice of matplotlib backend
               requires it.  It also modifies the %run command to correctly
               execute (without blocking) any matplotlib-based script which
               calls show() at the end.
 
        -tk    The -g/q/wthread options, and -pylab (if matplotlib is
               configured to use GTK, QT or WX), will normally block Tk
               graphical interfaces.  This means that when GTK, QT or WX
               threading is active, any attempt to open a Tk GUI will result in
               a dead window, and possibly cause the Python interpreter to
               crash.  An extra option, -tk, is available to address this
               issue.  It can ONLY be given as a SECOND option after any of the
               above (-gthread, -qthread, -wthread or -pylab).
 
               If -tk is given, IPython will try to coordinate Tk threading
               with GTK, QT or WX.  This is however potentially unreliable, and
               you will have to test on your platform and Python configuration
               to determine whether it works for you.  Debian users have
               reported success, apparently due to the fact that Debian builds
               all of Tcl, Tk, Tkinter and Python with pthreads support.  Under
               other Linux environments (such as Fedora Core 2/3), this option
               has caused random crashes and lockups of the Python interpreter.
               Under other operating systems (Mac OSX and Windows), you'll need
               to try it to find out, since currently no user reports are
               available.
 
               There is unfortunately no way for IPython to determine  at  run-
               time  whether -tk will work reliably or not, so you will need to
               do some experiments before relying on it for regular work.
 
 A WARNING ABOUT SIGNALS AND THREADS
 
        When any of the thread systems (GTK, QT or WX) are active, either
        directly or via -pylab with a threaded backend, it is impossible to
        interrupt long-running Python code via Ctrl-C.  IPython can not pass
        the KeyboardInterrupt exception (or the underlying SIGINT) across
        threads, so any long-running process started from IPython will run to
        completion, or will have to be killed via an external (OS-based)
        mechanism.
 
        To the best of my knowledge, this limitation is imposed by the Python
        interpreter itself, and it comes from the difficulty of writing
        portable signal/threaded code.  If any user is an expert on this topic
        and can suggest a better solution, I would love to hear about it.  In
        the IPython sources, look at the Shell.py module, and in particular at
        the runcode() method.
 
 REGULAR OPTIONS
        After the above threading options have been given, regular options  can
        follow  in any order.  All options can be abbreviated to their shortest
        non-ambiguous form and are case-sensitive.  One or two  dashes  can  be
        used.   Some options have an alternate short form, indicated after a |.
 
        Most options can also be set from your  ipythonrc  configuration  file.
        See the provided examples for assistance.  Options given on the comman-
        dline override the values set in the ipythonrc file.
 
        All options with a [no] prepended can be specified in negated form
        (using -nooption instead of -option) to turn the feature off.
 
        -h, --help
               Show summary of options.
 
        -pylab This can only be given as the first option passed to IPython (it
               will have no effect in any other position). It adds special sup-
               port   for  the  matplotlib  library  (http://matplotlib.source-
               forge.net), allowing interactive usage of any of its backends as
               defined  in  the  user’s  .matplotlibrc  file.  It automatically
               activates GTK or WX threading for IPyhton if the choice of  mat-
               plotlib  backend requires it.  It also modifies the @run command
               to correctly execute  (without  blocking)  any  matplotlib-based
               script which calls show() at the end.
 
        -autocall <val>
               Make IPython automatically call any callable object even if you
               didn't type explicit parentheses. For example, 'str 43' becomes
               'str(43)' automatically.  The value can be '0' to disable the
               feature, '1' for 'smart' autocall, where it is not applied if
               there are no more arguments on the line, and '2' for 'full'
               autocall, where all callable objects are automatically called
               (even if no arguments are present).  The default is '1'.
 
        -[no]autoindent
               Turn automatic indentation on/off.
 
        -[no]automagic
               Make magic commands automatic (without needing their first char-
               acter to be %).  Type %magic at  the  IPython  prompt  for  more
               information.
 
        -[no]autoedit_syntax
               When a syntax error occurs after editing a file, automatically
               open the file to the trouble causing line for convenient fixing.
 
        -[no]banner
               Print the intial information banner (default on).
 
        -c <command>
               Execute  the  given  command  string, and set sys.argv to [’c’].
               This is similar to the -c option in  the  normal  Python  inter-
               preter.
 
        -cache_size|cs <n>
               Size  of  the output cache (maximum number of entries to hold in
               memory).  The default is 1000, you can change it permanently  in
               your  config  file.   Setting  it  to  0 completely disables the
               caching system, and the minimum value accepted  is  20  (if  you
               provide  a value less than 20, it is reset to 0 and a warning is
               issued).  This limit is defined because otherwise  you’ll  spend
               more time re-flushing a too small cache than working.
 
        -classic|cl
               Gives IPython a similar feel to the classic Python prompt.
 
        -colors <scheme>
               Color  scheme  for  prompts  and exception reporting.  Currently
               implemented: NoColor, Linux, and LightBG.
 
        -[no]color_info
               IPython can display information about objects via a set of func-
               tions, and optionally can use colors for this, syntax highlight-
               ing source code and various other  elements.   However,  because
               this  information  is  passed  through a pager (like ’less’) and
               many pagers get confused with color codes, this option is off by
               default.   You  can  test  it and turn it on permanently in your
               ipythonrc file if it works for you.  As a reference, the  ’less’
               pager  supplied  with  Mandrake 8.2 works ok, but that in RedHat
               7.2 doesn’t.
 
               Test it and turn it on permanently if it works with your system.
               The  magic function @color_info allows you to toggle this inter-
               actively for testing.
 
        -[no]confirm_exit
               Set to confirm when you try to exit IPython with  an  EOF  (Con-
               trol-D in Unix, Control-Z/Enter in Windows). Note that using the
               magic functions @Exit or @Quit you  can  force  a  direct  exit,
               bypassing any confirmation.
 
        -[no]debug
               Show  information  about the loading process. Very useful to pin
               down problems with your configuration files or  to  get  details
               about session restores.
 
        -[no]deep_reload
               IPython  can use the deep_reload module which reloads changes in
               modules recursively (it replaces the reload() function,  so  you
               don’t need to change anything to use it). deep_reload() forces a
               full reload of modules whose code may have  changed,  which  the
               default reload() function does not.
 
               When  deep_reload  is off, IPython will use the normal reload(),
               but deep_reload will still be available as dreload(). This  fea-
               ture  is  off  by default [which means that you have both normal
               reload() and dreload()].
 
        -editor <name>
               Which editor to use with the @edit command. By default,  IPython
               will  honor  your EDITOR environment variable (if not set, vi is
               the Unix default and notepad the Windows one). Since this editor
               is  invoked on the fly by IPython and is meant for editing small
               code snippets, you may want to use a small,  lightweight  editor
               here (in case your default EDITOR is something like Emacs).
 
        -ipythondir <name>
               The  name  of  your  IPython configuration directory IPYTHONDIR.
               This can also be  specified  through  the  environment  variable
               IPYTHONDIR.
 
        -log|l Generate  a log file of all input. The file is named
               ipython_log.py in your current directory (which prevents logs
               from multiple IPython sessions from trampling each other). You
               can use this to later restore a session by loading your logfile
               as a file to be executed with option -logplay (see below).
 
        -logfile|lf
               Specify the name of your logfile.
 
        -logplay|lp
               Replay  a previous log. For restoring a session as close as pos-
               sible to the state you left it in, use this option  (don’t  just
               run the logfile). With -logplay, IPython will try to reconstruct
               the previous working environment in full, not just  execute  the
               commands in the logfile.
               When  a  session is restored, logging is automatically turned on
               again with the name of the logfile it was invoked  with  (it  is
               read  from the log header). So once you’ve turned logging on for
               a session, you can quit IPython and reload it as many  times  as
               you  want  and  it  will continue to log its history and restore
               from the beginning every time.
 
               Caveats: there are limitations in this option. The history vari-
               ables  _i*,_* and _dh don’t get restored properly. In the future
               we will try to implement full  session  saving  by  writing  and
               retrieving  a failed because of inherent limitations of Python’s
               Pickle module, so this may have to wait.
 
        -[no]messages
               Print messages which IPython collects about its startup  process
               (default on).
 
        -[no]pdb
               Automatically  call the pdb debugger after every uncaught excep-
               tion. If you are used to debugging  using  pdb,  this  puts  you
               automatically  inside of it after any call (either in IPython or
               in code called by it) which triggers  an  exception  which  goes
               uncaught.
 
        -[no]pprint
               IPython  can  optionally  use the pprint (pretty printer) module
               for displaying results. pprint tends to give a nicer display  of
               nested  data structures. If you like it, you can turn it on per-
               manently in your config file (default off).
 
        -profile|p <name>
               Assume that your config file is ipythonrc-<name> (looks in  cur-
               rent dir first, then in IPYTHONDIR). This is a quick way to keep
               and load multiple config files for different  tasks,  especially
               if  you  use  the include option of config files. You can keep a
               basic IPYTHONDIR/ipythonrc file and then have  other  ’profiles’
               which  include  this  one  and  load extra things for particular
               tasks. For example:
 
               1) $HOME/.ipython/ipythonrc : load basic things you always want.
               2)  $HOME/.ipython/ipythonrc-math  :  load  (1)  and basic math-
               related modules.
               3) $HOME/.ipython/ipythonrc-numeric : load (1) and  Numeric  and
               plotting modules.
 
               Since  it is possible to create an endless loop by having circu-
               lar file inclusions, IPython will stop if it reaches  15  recur-
               sive inclusions.
 
        -prompt_in1|pi1 <string>
               Specify  the string used for input prompts. Note that if you are
               using numbered prompts, the number is represented with a ’\#’ in
               the  string.  Don’t forget to quote strings with spaces embedded
               in them. Default: ’In [\#]:’.
 
               Most bash-like  escapes  can  be  used  to  customize  IPython’s
               prompts, as well as a few additional ones which are IPython-spe-
               cific.  All valid prompt escapes are described in detail in  the
               Customization section of the IPython HTML/PDF manual.
 
        -prompt_in2|pi2 <string>
               Similar  to  the  previous option, but used for the continuation
               prompts. The special sequence ’\D’ is similar to ’\#’, but  with
               all  digits  replaced  dots  (so  you can have your continuation
               prompt aligned with your  input  prompt).  Default:  ’    .\D.:’
               (note three spaces at the start for alignment with ’In [\#]’).
 
        -prompt_out|po <string>
               String   used   for  output  prompts,  also  uses  numbers  like
               prompt_in1.  Default: ’Out[\#]:’.
 
        -quick Start in bare bones mode (no config file loaded).
 
        -rcfile <name>
               Name of your  IPython  resource  configuration  file.   normally
               IPython    loads   ipythonrc   (from   current   directory)   or
               IPYTHONDIR/ipythonrc.  If the loading of your config file fails,
               IPython  starts  with  a  bare  bones  configuration (no modules
               loaded at all).
 
        -[no]readline
               Use the readline library, which is needed to support  name  com-
               pletion  and  command history, among other things. It is enabled
               by default, but may cause  problems  for  users  of  X/Emacs  in
               Python comint or shell buffers.
 
               Note  that  emacs ’eterm’ buffers (opened with M-x term) support
               IPython’s readline and syntax coloring fine, only  ’emacs’  (M-x
               shell and C-c !)  buffers do not.
 
        -screen_length|sl <n>
               Number  of lines of your screen.  This is used to control print-
               ing of very long strings.  Strings longer than  this  number  of
               lines  will be sent through a pager instead of directly printed.
 
               The default value for this is 0, which means IPython will  auto-
               detect  your  screen  size  every time it needs to print certain
               potentially long strings (this doesn’t change  the  behavior  of
               the  ’print’  keyword,  it’s  only triggered internally). If for
               some reason this isn’t working well (it needs  curses  support),
               specify it yourself. Otherwise don’t change the default.
 
        -separate_in|si <string>
               Separator before input prompts.  Default ’0.
 
        -separate_out|so <string>
               Separator before output prompts.  Default: 0 (nothing).
 
        -separate_out2|so2 <string>
               Separator after output prompts.  Default: 0 (nothing).
 
        -nosep Shorthand for ’-separate_in 0 -separate_out 0 -separate_out2 0’.
               Simply removes all input/output separators.
 
        -upgrade
               Allows you to upgrade your  IPYTHONDIR  configuration  when  you
               install  a  new  version  of  IPython.   Since  new versions may
               include new command lines options or example files, this  copies
               updated ipythonrc-type files.  However, it backs up (with a .old
               extension) all files which it overwrites so that you  can  merge
               back any custimizations you might have in your personal files.
 
        -Version
               Print version information and exit.
 
+       -wxversion <string>
+              Select a specific version of wxPython (used in conjunction with
+              -wthread). Requires the wxversion module, part of recent
+              wxPython distributions.
+
        -xmode <modename>
               Mode  for  exception reporting.  The valid modes are Plain, Con-
               text, and Verbose.
 
               - Plain: similar to python’s normal traceback printing.
 
               - Context: prints 5 lines of context  source  code  around  each
               line in the traceback.
 
               - Verbose: similar to Context, but additionally prints the vari-
               ables currently visible where the exception happened (shortening
               their  strings if too long).  This can potentially be very slow,
               if you happen to have a huge data structure whose string  repre-
               sentation  is  complex  to compute.  Your computer may appear to
               freeze for a while with cpu usage at 100%.  If this occurs,  you
               can cancel the traceback with Ctrl-C (maybe hitting it more than
               once).
 
 
 EMBEDDING
        It is possible to start an IPython instance inside your own Python pro-
        grams.  In the documentation example files there are some illustrations
        on how to do this.
 
        This feature allows you to evalutate  dynamically  the  state  of  your
        code,  operate  with  your  variables, analyze them, etc.  Note however
        that any changes you make to values while in the shell do NOT propagate
        back  to  the running code, so it is safe to modify your values because
        you won’t break your code in bizarre ways by doing so.
 """
 
 cmd_line_usage = __doc__
 
 #---------------------------------------------------------------------------
 interactive_usage = """
 IPython -- An enhanced Interactive Python
 =========================================
 
 IPython offers a combination of convenient shell features, special commands
 and a history mechanism for both input (command history) and output (results
 caching, similar to Mathematica). It is intended to be a fully compatible
 replacement for the standard Python interpreter, while offering vastly
 improved functionality and flexibility.
 
 At your system command line, type 'ipython -help' to see the command line
 options available. This document only describes interactive features.
 
 Warning: IPython relies on the existence of a global variable called __IP which
 controls the shell itself. If you redefine __IP to anything, bizarre behavior
 will quickly occur.
 
 MAIN FEATURES
 
 * Access to the standard Python help. As of Python 2.1, a help system is
   available with access to object docstrings and the Python manuals. Simply
   type 'help' (no quotes) to access it.
 
 * Magic commands: type %magic for information on the magic subsystem.
 
 * System command aliases, via the %alias command or the ipythonrc config file.
 
 * Dynamic object information:
 
   Typing ?word or word? prints detailed information about an object.  If
   certain strings in the object are too long (docstrings, code, etc.) they get
   snipped in the center for brevity.
 
   Typing ??word or word?? gives access to the full information without
   snipping long strings. Long strings are sent to the screen through the less
   pager if longer than the screen, printed otherwise.
 
   The ?/?? system gives access to the full source code for any object (if
   available), shows function prototypes and other useful information.
 
   If you just want to see an object's docstring, type '%pdoc object' (without
   quotes, and without % if you have automagic on).
 
   Both %pdoc and ?/?? give you access to documentation even on things which are
   not explicitely defined. Try for example typing {}.get? or after import os,
   type os.path.abspath??. The magic functions %pdef, %source and %file operate
   similarly.
 
 * Completion in the local namespace, by typing TAB at the prompt.
 
   At any time, hitting tab will complete any available python commands or
   variable names, and show you a list of the possible completions if there's
   no unambiguous one. It will also complete filenames in the current directory.
 
   This feature requires the readline and rlcomplete modules, so it won't work
   if your Python lacks readline support (such as under Windows).
 
 * Search previous command history in two ways (also requires readline):
 
   - Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to
   search through only the history items that match what you've typed so
   far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like
   normal arrow keys.
 
   - Hit Ctrl-r: opens a search prompt. Begin typing and the system searches
   your history for lines that match what you've typed so far, completing as
   much as it can.
 
 * Persistent command history across sessions (readline required).
 
 * Logging of input with the ability to save and restore a working session.
   
 * System escape with !. Typing !ls will run 'ls' in the current directory.
 
 * The reload command does a 'deep' reload of a module: changes made to the
   module since you imported will actually be available without having to exit.
 
 * Verbose and colored exception traceback printouts. See the magic xmode and
   xcolor functions for details (just type %magic).
 
 * Input caching system:
 
   IPython offers numbered prompts (In/Out) with input and output caching. All
   input is saved and can be retrieved as variables (besides the usual arrow
   key recall).
 
   The following GLOBAL variables always exist (so don't overwrite them!):
   _i: stores previous input.
   _ii: next previous.
   _iii: next-next previous.
   _ih : a list of all input _ih[n] is the input from line n.
 
   Additionally, global variables named _i<n> are dynamically created (<n>
   being the prompt counter), such that _i<n> == _ih[<n>]
 
   For example, what you typed at prompt 14 is available as _i14 and _ih[14].
 
   You can create macros which contain multiple input lines from this history,
   for later re-execution, with the %macro function.
 
   The history function %hist allows you to see any part of your input history
   by printing a range of the _i variables. Note that inputs which contain
   magic functions (%) appear in the history with a prepended comment. This is
   because they aren't really valid Python code, so you can't exec them.
 
 * Output caching system:
 
   For output that is returned from actions, a system similar to the input
   cache exists but using _ instead of _i. Only actions that produce a result
   (NOT assignments, for example) are cached. If you are familiar with
   Mathematica, IPython's _ variables behave exactly like Mathematica's %
   variables.
 
   The following GLOBAL variables always exist (so don't overwrite them!):
   _ (one underscore): previous output.
   __ (two underscores): next previous.
   ___ (three underscores): next-next previous.
 
   Global variables named _<n> are dynamically created (<n> being the prompt
   counter), such that the result of output <n> is always available as _<n>.
 
   Finally, a global dictionary named _oh exists with entries for all lines
   which generated output.
 
 * Directory history:
 
   Your history of visited directories is kept in the global list _dh, and the
   magic %cd command can be used to go to any entry in that list.
 
 * Auto-parentheses and auto-quotes (adapted from Nathan Gray's LazyPython)
 
     1. Auto-parentheses
         Callable objects (i.e. functions, methods, etc) can be invoked like
         this (notice the commas between the arguments):
             >>> callable_ob arg1, arg2, arg3
         and the input will be translated to this:
             --> callable_ob(arg1, arg2, arg3)
         You can force auto-parentheses by using '/' as the first character
         of a line.  For example:
             >>> /globals             # becomes 'globals()'
         Note that the '/' MUST be the first character on the line!  This
         won't work:
             >>> print /globals    # syntax error
             
         In most cases the automatic algorithm should work, so you should
         rarely need to explicitly invoke /. One notable exception is if you
         are trying to call a function with a list of tuples as arguments (the
         parenthesis will confuse IPython):
             In [1]: zip (1,2,3),(4,5,6)  # won't work
         but this will work:
             In [2]: /zip (1,2,3),(4,5,6)
             ------> zip ((1,2,3),(4,5,6))
             Out[2]= [(1, 4), (2, 5), (3, 6)]        
 
         IPython tells you that it has altered your command line by
         displaying the new command line preceded by -->.  e.g.:
             In [18]: callable list
             -------> callable (list) 
 
     2. Auto-Quoting
         You can force auto-quoting of a function's arguments by using ',' as
         the first character of a line.  For example:
             >>> ,my_function /home/me   # becomes my_function("/home/me")
 
         If you use ';' instead, the whole argument is quoted as a single
         string (while ',' splits on whitespace):
             >>> ,my_function a b c   # becomes my_function("a","b","c")
             >>> ;my_function a b c   # becomes my_function("a b c")
 
         Note that the ',' MUST be the first character on the line!  This
         won't work:
             >>> x = ,my_function /home/me    # syntax error
 """

doc/ChangeLog

@@ -1,4794 +1,4799 b''
 2006-01-08  Fernando Perez  <[e-mail]>
 
+	* IPython/Shell.py (IPShellWX.__init__): add support for WXPython
+	version selection (new -wxversion command line and ipythonrc
+	parameter).  Patch contributed by Arnd Baecker
+	<arnd.baecker-AT-web.de>.
+
 	* IPython/iplib.py (embed_mainloop): fix tab-completion in
 	embedded instances, for variables defined at the interactive
 	prompt of the embedded ipython.  Reported by Arnd.
 
 	* IPython/Magic.py (magic_autocall): Fix %autocall magic.  Now
 	it can be used as a (stateful) toggle, or with a direct parameter.
 
 	* IPython/ultraTB.py (_fixed_getinnerframes): remove debug assert which
 	could be triggered in certain cases and cause the traceback
 	printer not to work.
 
 2006-01-07  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (_should_recompile): Small fix, closes
 	http://www.scipy.net/roundup/ipython/issue48.  Patch by Scott.
 
 2006-01-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): fix bug in the GTK
 	backend for matplotlib (100% cpu utiliziation).  Thanks to Charlie
 	Moad for help with tracking it down.
 
 	* IPython/iplib.py (handle_auto): fix autocall handling for
 	objects which support BOTH __getitem__ and __call__ (so that f [x]
 	is left alone, instead of becoming f([x]) automatically).
 
 	* IPython/Magic.py (magic_cd): fix crash when cd -b was used.
 	Ville's patch.
 
 2006-01-03  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): changed autocall semantics to
 	include 'smart' mode, where the autocall transformation is NOT
 	applied if there are no arguments on the line.  This allows you to
 	just type 'foo' if foo is a callable to see its internal form,
 	instead of having it called with no arguments (typically a
 	mistake).  The old 'full' autocall still exists: for that, you
 	need to set the 'autocall' parameter to 2 in your ipythonrc file.
 
 	* IPython/completer.py (Completer.attr_matches): add
 	tab-completion support for Enthoughts' traits.  After a report by
 	Arnd and a patch by Prabhu.
 
 2006-01-02  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (_fixed_getinnerframes): added Alex
 	Schmolck's patch to fix inspect.getinnerframes().
 
 	* IPython/iplib.py (InteractiveShell.__init__): significant fixes
 	for embedded instances, regarding handling of namespaces and items
 	added to the __builtin__ one.  Multiple embedded instances and
 	recursive embeddings should work better now (though I'm not sure
 	I've got all the corner cases fixed, that code is a bit of a brain
 	twister).
 
 	* IPython/Magic.py (magic_edit): added support to edit in-memory
 	macros (automatically creates the necessary temp files).  %edit
 	also doesn't return the file contents anymore, it's just noise.
 
 	* IPython/completer.py (Completer.attr_matches): revert change to
 	complete only on attributes listed in __all__.  I realized it
 	cripples the tab-completion system as a tool for exploring the
 	internals of unknown libraries (it renders any non-__all__
 	attribute off-limits).  I got bit by this when trying to see
 	something inside the dis module.
 
 2005-12-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): add .meta
 	namespace for users and extension writers to hold data in.  This
 	follows the discussion in
 	http://projects.scipy.org/ipython/ipython/wiki/RefactoringIPython.
 
 	* IPython/completer.py (IPCompleter.complete): small patch to help
 	tab-completion under Emacs, after a suggestion by John Barnard
 	<barnarj-AT-ccf.org>.
 
 	* IPython/Magic.py (Magic.extract_input_slices): added support for
 	the slice notation in magics to use N-M to represent numbers N...M
 	(closed endpoints).  This is used by %macro and %save.
 
 	* IPython/completer.py (Completer.attr_matches): for modules which
 	define __all__, complete only on those.  After a patch by Jeffrey
 	Collins <jcollins_boulder-AT-earthlink.net>.  Also, clean up and
 	speed up this routine.
 
 	* IPython/Logger.py (Logger.log): fix a history handling bug.  I
 	don't know if this is the end of it, but the behavior now is
 	certainly much more correct.  Note that coupled with macros,
 	slightly surprising (at first) behavior may occur: a macro will in
 	general expand to multiple lines of input, so upon exiting, the
 	in/out counters will both be bumped by the corresponding amount
 	(as if the macro's contents had been typed interactively).  Typing
 	%hist will reveal the intermediate (silently processed) lines.
 
 	* IPython/Magic.py (magic_run): fix a subtle bug which could cause
 	pickle to fail (%run was overwriting __main__ and not restoring
 	it, but pickle relies on __main__ to operate).
 
 	* IPython/iplib.py (InteractiveShell): fix pdb calling: I'm now
 	using properties, but forgot to make the main InteractiveShell
 	class a new-style class.  Properties fail silently, and
 	misteriously, with old-style class (getters work, but
 	setters don't do anything).
 
 2005-12-30  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_history): fix history reporting bug (I
 	know some nasties are still there, I just can't seem to find a
 	reproducible test case to track them down; the input history is
 	falling out of sync...)
 
 	* IPython/iplib.py (handle_shell_escape): fix bug where both
 	aliases and system accesses where broken for indented code (such
 	as loops).
 
 	* IPython/genutils.py (shell): fix small but critical bug for
 	win32 system access.
 
 2005-12-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (showtraceback): remove use of the
 	sys.last_{type/value/traceback} structures, which are non
 	thread-safe.
 	(_prefilter): change control flow to ensure that we NEVER
 	introspect objects when autocall is off.  This will guarantee that
 	having an input line of the form 'x.y', where access to attribute
 	'y' has side effects, doesn't trigger the side effect TWICE.  It
 	is important to note that, with autocall on, these side effects
 	can still happen.
 	(ipsystem): new builtin, to complete the ip{magic/alias/system}
 	trio.  IPython offers these three kinds of special calls which are
 	not python code, and it's a good thing to have their call method
 	be accessible as pure python functions (not just special syntax at
 	the command line).  It gives us a better internal implementation
 	structure, as well as exposing these for user scripting more
 	cleanly.
 
 	* IPython/macro.py (Macro.__init__): moved macros to a standalone
 	file.  Now that they'll be more likely to be used with the
 	persistance system (%store), I want to make sure their module path
 	doesn't change in the future, so that we don't break things for
 	users' persisted data.
 
 	* IPython/iplib.py (autoindent_update): move indentation
 	management into the _text_ processing loop, not the keyboard
 	interactive one.  This is necessary to correctly process non-typed
 	multiline input (such as macros).
 
 	* IPython/Magic.py (Magic.format_latex): patch by Stefan van der
 	Walt <stefan-AT-sun.ac.za> to fix latex formatting of docstrings,
 	which was producing problems in the resulting manual.
 	(magic_whos): improve reporting of instances (show their class,
 	instead of simply printing 'instance' which isn't terribly
 	informative).
 
 	* IPython/genutils.py (shell): commit Jorgen Stenarson's patch
 	(minor mods) to support network shares under win32.
 
 	* IPython/winconsole.py (get_console_size): add new winconsole
 	module and fixes to page_dumb() to improve its behavior under
 	win32.  Contributed by Alexander Belchenko <bialix-AT-ukr.net>.
 
 	* IPython/Magic.py (Macro): simplified Macro class to just
 	subclass list.  We've had only 2.2 compatibility for a very long
 	time, yet I was still avoiding subclassing the builtin types.  No
 	more (I'm also starting to use properties, though I won't shift to
 	2.3-specific features quite yet).
 	(magic_store): added Ville's patch for lightweight variable
 	persistence, after a request on the user list by Matt Wilkie
 	<maphew-AT-gmail.com>.  The new %store magic's docstring has full
 	details.
 
 	* IPython/iplib.py (InteractiveShell.post_config_initialization):
 	changed the default logfile name from 'ipython.log' to
 	'ipython_log.py'.  These logs are real python files, and now that
 	we have much better multiline support, people are more likely to
 	want to use them as such.  Might as well name them correctly.
 
 	* IPython/Magic.py: substantial cleanup.  While we can't stop
 	using magics as mixins, due to the existing customizations 'out
 	there' which rely on the mixin naming conventions, at least I
 	cleaned out all cross-class name usage.  So once we are OK with
 	breaking compatibility, the two systems can be separated.
 
 	* IPython/Logger.py: major cleanup.  This one is NOT a mixin
 	anymore, and the class is a fair bit less hideous as well.  New
 	features were also introduced: timestamping of input, and logging
 	of output results.  These are user-visible with the -t and -o
 	options to %logstart.  Closes
 	http://www.scipy.net/roundup/ipython/issue11 and a request by
 	William Stein (SAGE developer - http://modular.ucsd.edu/sage).
 
 2005-12-28  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_shell_escape): add Ville's patch to
 	better hadnle backslashes in paths.  See the thread 'More Windows
 	questions part 2 - \/ characters revisited' on the iypthon user
 	list:
 	http://scipy.net/pipermail/ipython-user/2005-June/000907.html
 
 	(InteractiveShell.__init__): fix tab-completion bug in threaded shells.
 
 	(InteractiveShell.__init__): change threaded shells to not use the
 	ipython crash handler.  This was causing more problems than not,
 	as exceptions in the main thread (GUI code, typically) would
 	always show up as a 'crash', when they really weren't.
 
 	The colors and exception mode commands (%colors/%xmode) have been
 	synchronized to also take this into account, so users can get
 	verbose exceptions for their threaded code as well.  I also added
 	support for activating pdb inside this exception handler as well,
 	so now GUI authors can use IPython's enhanced pdb at runtime.
 
 	* IPython/ipmaker.py (make_IPython): make the autoedit_syntax flag
 	true by default, and add it to the shipped ipythonrc file.  Since
 	this asks the user before proceeding, I think it's OK to make it
 	true by default.
 
 	* IPython/Magic.py (magic_exit): make new exit/quit magics instead
 	of the previous special-casing of input in the eval loop.  I think
 	this is cleaner, as they really are commands and shouldn't have
 	a special role in the middle of the core code.
 
 2005-12-27  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (edit_syntax_error): added support for
 	automatically reopening the editor if the file had a syntax error
 	in it.  Thanks to scottt who provided the patch at:
 	http://www.scipy.net/roundup/ipython/issue36 (slightly modified
 	version committed).
 
 	* IPython/iplib.py (handle_normal): add suport for multi-line
 	input with emtpy lines.  This fixes
 	http://www.scipy.net/roundup/ipython/issue43 and a similar
 	discussion on the user list.
 
 	WARNING: a behavior change is necessarily introduced to support
 	blank lines: now a single blank line with whitespace does NOT
 	break the input loop, which means that when autoindent is on, by
 	default hitting return on the next (indented) line does NOT exit.
 
 	Instead, to exit a multiline input you can either have:
 
 	  - TWO whitespace lines (just hit return again), or
 	  - a single whitespace line of a different length than provided
 	by the autoindent (add or remove a space).
 
 	* IPython/completer.py (MagicCompleter.__init__): new 'completer'
 	module to better organize all readline-related functionality.
 	I've deleted FlexCompleter and put all completion clases here.
 
 	* IPython/iplib.py (raw_input): improve indentation management.
 	It is now possible to paste indented code with autoindent on, and
 	the code is interpreted correctly (though it still looks bad on
 	screen, due to the line-oriented nature of ipython).
 	(MagicCompleter.complete): change behavior so that a TAB key on an
 	otherwise empty line actually inserts a tab, instead of completing
 	on the entire global namespace.  This makes it easier to use the
 	TAB key for indentation.  After a request by Hans Meine
 	<hans_meine-AT-gmx.net>
 	(_prefilter): add support so that typing plain 'exit' or 'quit'
 	does a sensible thing.  Originally I tried to deviate as little as
 	possible from the default python behavior, but even that one may
 	change in this direction (thread on python-dev to that effect).
 	Regardless, ipython should do the right thing even if CPython's
 	'>>>' prompt doesn't.
 	(InteractiveShell): removed subclassing code.InteractiveConsole
 	class.  By now we'd overridden just about all of its methods: I've
 	copied the remaining two over, and now ipython is a standalone
 	class.  This will provide a clearer picture for the chainsaw
 	branch refactoring.
 
 2005-12-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): harden reporting against
 	failures for objects which break when dir() is called on them.
 
 	* IPython/FlexCompleter.py (Completer.__init__): Added support for
 	distinct local and global namespaces in the completer API.  This
 	change allows us top properly handle completion with distinct
 	scopes, including in embedded instances (this had never really
 	worked correctly).
 
 	Note: this introduces a change in the constructor for
 	MagicCompleter, as a new global_namespace parameter is now the
 	second argument (the others were bumped one position).
 
 2005-12-25  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (embed_mainloop): fix tab-completion in
 	embedded instances (which can be done now thanks to Vivian's
 	frame-handling fixes for pdb).
 	(InteractiveShell.__init__): Fix namespace handling problem in
 	embedded instances.  We were overwriting __main__ unconditionally,
 	and this should only be done for 'full' (non-embedded) IPython;
 	embedded instances must respect the caller's __main__.  Thanks to
 	a bug report by Yaroslav Bulatov <yaroslavvb-AT-gmail.com>
 
 2005-12-24  Fernando Perez  <[e-mail]>
 
 	* setup.py: added download_url to setup().  This registers the
 	download address at PyPI, which is not only useful to humans
 	browsing the site, but is also picked up by setuptools (the Eggs
 	machinery).  Thanks to Ville and R. Kern for the info/discussion
 	on this.
 
 2005-12-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Debugger.py (Pdb.__init__): Major pdb mode enhancements.
 	This brings a lot of nice functionality to the pdb mode, which now
 	has tab-completion, syntax highlighting, and better stack handling
 	than before.  Many thanks to Vivian De Smedt
 	<vivian-AT-vdesmedt.com> for the original patches.
 
 2005-12-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): fix mainloop() calling
 	sequence to consistently accept the banner argument.  The
 	inconsistency was tripping SAGE, thanks to Gary Zablackis
 	<gzabl-AT-yahoo.com> for the report.
 
 2005-11-15  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.post_config_initialization):
 	Fix bug where a naked 'alias' call in the ipythonrc file would
 	cause a crash.  Bug reported by Jorgen Stenarson.
 
 2005-11-15  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): cleanups which should improve
 	startup time.
 
 	* IPython/iplib.py (runcode): my globals 'fix' for embedded
 	instances had introduced a bug with globals in normal code.  Now
 	it's working in all cases.
 
 	* IPython/Magic.py (magic_psearch): Finish wildcard cleanup and
 	API changes.  A new ipytonrc option, 'wildcards_case_sensitive'
 	has been introduced to set the default case sensitivity of the
 	searches.  Users can still select either mode at runtime on a
 	per-search basis.
 
 2005-11-13 Fernando Perez   <[e-mail]>
 
 	* IPython/wildcard.py (NameSpace.__init__): fix resolution of
 	attributes in wildcard searches for subclasses.  Modified version
 	of a patch by Jorgen.
 
 2005-11-12 Fernando Perez   <[e-mail]>
 
 	* IPython/iplib.py (embed_mainloop): Fix handling of globals for
 	embedded instances.  I added a user_global_ns attribute to the
 	InteractiveShell class to handle this.
 
 2005-10-31  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): Change timeout_add to
 	idle_add, which fixes horrible keyboard lag problems under gtk 2.6
 	(reported under win32, but may happen also in other platforms).
 	Bug report and fix courtesy of Sean Moore <smm-AT-logic.bm>
 
 2005-10-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_psearch): new support for wildcard
 	patterns.  Now, typing ?a*b will list all names which begin with a
 	and end in b, for example.  The %psearch magic has full
 	docstrings.  Many thanks to Jörgen Stenarson
 	<jorgen.stenarson-AT-bostream.nu>, author of the patches
 	implementing this functionality.
 
 2005-09-27  Fernando Perez  <[e-mail]>
 
 	* Manual: fixed long-standing annoyance of double-dashes (as in
 	--prefix=~, for example) being stripped in the HTML version.  This
 	is a latex2html bug, but a workaround was provided.  Many thanks
 	to George K. Thiruvathukal <gthiruv-AT-luc.edu> for the detailed
 	help, and Michael Tobis <mtobis-AT-gmail.com> for getting the ball
 	rolling.  This seemingly small issue had tripped a number of users
 	when first installing, so I'm glad to see it gone.
 	
 2005-09-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/numeric_formats.py: fix missing import,
 	reported by Stephen Walton.
 
 2005-09-24  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py: finish demo module, fully documented now.
 
 	* IPython/genutils.py (file_read): simple little utility to read a
 	file and ensure it's closed afterwards.
 
 2005-09-23  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py (Demo.__init__): added support for individually
 	tagging blocks for automatic execution.
 
 	* IPython/Magic.py (magic_pycat): new %pycat magic for showing
 	syntax-highlighted python sources, requested by John.
 
 2005-09-22  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py (Demo.again): fix bug where again() blocks after
 	finishing.
 
 	* IPython/genutils.py (shlex_split): moved from Magic to here,
 	where all 2.2 compatibility stuff lives.  I needed it for demo.py.
 
 	* IPython/demo.py (Demo.__init__): added support for silent
 	blocks, improved marks as regexps, docstrings written.
 	(Demo.__init__): better docstring, added support for sys.argv.
 
 	* IPython/genutils.py (marquee): little utility used by the demo
 	code, handy in general.
 
 	* IPython/demo.py (Demo.__init__): new class for interactive
 	demos.  Not documented yet, I just wrote it in a hurry for
 	scipy'05.  Will docstring later.
 
 2005-09-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (sigint_handler): Drastic simplification which
 	also seems to make Ctrl-C work correctly across threads!  This is
 	so simple, that I can't beleive I'd missed it before.  Needs more
 	testing, though.
 	(KBINT): Never mind, revert changes.  I'm sure I'd tried something
 	like this before...
 
 	* IPython/genutils.py (get_home_dir): add protection against
 	non-dirs in win32 registry.
 
 	* IPython/iplib.py (InteractiveShell.alias_table_validate): fix
 	bug where dict was mutated while iterating (pysh crash).
 
 2005-09-06  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): Fix inconsistency arising from
 	spurious newlines added by this routine.  After a report by
 	F. Mantegazza.
 
 2005-09-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (hijack_gtk): remove pygtk.require("2.0")
 	calls.  These were a leftover from the GTK 1.x days, and can cause
 	problems in certain cases (after a report by John Hunter).
 
 	* IPython/iplib.py (InteractiveShell.__init__): Trap exception if
 	os.getcwd() fails at init time.  Thanks to patch from David Remahl
 	<chmod007-AT-mac.com>.
 	(InteractiveShell.__init__): prevent certain special magics from
 	being shadowed by aliases.  Closes
 	http://www.scipy.net/roundup/ipython/issue41.
 
 2005-08-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.complete): Added new
 	top-level completion method to expose the completion mechanism
 	beyond readline-based environments.
 
 2005-08-19  Fernando Perez  <[e-mail]>
 
 	* tools/ipsvnc (svnversion): fix svnversion capture.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Add has_readline
 	attribute to self, which was missing.  Before, it was set by a
 	routine which in certain cases wasn't being called, so the
 	instance could end up missing the attribute.  This caused a crash.
 	Closes http://www.scipy.net/roundup/ipython/issue40.
 
 2005-08-16  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): don't crash if object
 	contains non-string attribute.  Closes
 	http://www.scipy.net/roundup/ipython/issue38.
 
 2005-08-14  Fernando Perez  <[e-mail]>
 
 	* tools/ipsvnc: Minor improvements, to add changeset info.
 
 2005-08-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (runsource): remove self.code_to_run_src
 	attribute.  I realized this is nothing more than
 	'\n'.join(self.buffer), and having the same data in two different
 	places is just asking for synchronization bugs.  This may impact
 	people who have custom exception handlers, so I need to warn
 	ipython-dev about it (F. Mantegazza may use them).
 
 2005-07-29  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py: fix 2.2 compatibility (generators)
 
 2005-07-18  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (get_home_dir): fix to help users with
 	invalid $HOME under win32.
 
 2005-07-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (str_safe): Make unicode-safe.  Also remove
 	some old hacks and clean up a bit other routines; code should be
 	simpler and a bit faster.
 
 	* IPython/iplib.py (interact): removed some last-resort attempts
 	to survive broken stdout/stderr.  That code was only making it
 	harder to abstract out the i/o (necessary for gui integration),
 	and the crashes it could prevent were extremely rare in practice
 	(besides being fully user-induced in a pretty violent manner).
 
 	* IPython/genutils.py (IOStream.__init__): Simplify the i/o stuff.
 	Nothing major yet, but the code is simpler to read; this should
 	make it easier to do more serious modifications in the future.
 
 	* IPython/Extensions/InterpreterExec.py: Fix auto-quoting in pysh,
 	which broke in .15 (thanks to a report by Ville).
 
 	* IPython/Itpl.py (Itpl.__init__): add unicode support (it may not
 	be quite correct, I know next to nothing about unicode).  This
 	will allow unicode strings to be used in prompts, amongst other
 	cases.  It also will prevent ipython from crashing when unicode
 	shows up unexpectedly in many places.  If ascii encoding fails, we
 	assume utf_8.  Currently the encoding is not a user-visible
 	setting, though it could be made so if there is demand for it.
 
 	* IPython/ipmaker.py (make_IPython): remove old 2.1-specific hack.
 
 	* IPython/Struct.py (Struct.merge): switch keys() to iterator.
 
 	* IPython/background_jobs.py: moved 2.2 compatibility to genutils.
 
 	* IPython/genutils.py: Add 2.2 compatibility here, so all other
 	code can work transparently for 2.2/2.3.
 
 2005-07-16  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (ExceptionColors): Make a global variable
 	out of the color scheme table used for coloring  exception
 	tracebacks.  This allows user code to add new schemes at runtime.
 	This is a minimally modified version of the patch at
 	http://www.scipy.net/roundup/ipython/issue35, many thanks to pabw
 	for the contribution.
 
 	* IPython/FlexCompleter.py (Completer.attr_matches): Add a
 	slightly modified version of the patch in
 	http://www.scipy.net/roundup/ipython/issue34, which also allows me
 	to remove the previous try/except solution (which was costlier).
 	Thanks to Gaetan Lehmann <gaetan.lehmann-AT-jouy.inra.fr> for the fix.
 
 2005-06-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (write/write_err): Add methods to abstract all
 	I/O a bit more.
 
 	* IPython/Shell.py (IPShellGTK.mainloop): Fix GTK deprecation
 	warning, reported by Aric Hagberg, fix by JD Hunter.
 
 2005-06-02  *** Released version 0.6.15
 
 2005-06-01  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (MagicCompleter.file_matches): Fix
 	tab-completion of filenames within open-quoted strings.  Note that
 	this requires that in ~/.ipython/ipythonrc, users change the
 	readline delimiters configuration to read:
 
 	readline_remove_delims -/~
 	
 
 2005-05-31  *** Released version 0.6.14
 
 2005-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix crash for tracebacks
 	with files not on the filesystem.  Reported by Eliyahu Sandler
 	<[e-mail]>
 
 2005-05-22  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py: Fix a few crashes in the --upgrade option.
 	After an initial report by LUK ShunTim <[e-mail]>.
 
 2005-05-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (safe_execfile): close a file which could be
 	left open (causing problems in win32, which locks open files).
 	Thanks to a bug report by D Brown <[e-mail]>.
 
 2005-05-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): pass all
 	keyword arguments correctly to safe_execfile().
 
 2005-05-13  Fernando Perez  <[e-mail]>
 
 	* ipython.1: Added info about Qt to manpage, and threads warning
 	to usage page (invoked with --help).
 
 	* IPython/iplib.py (MagicCompleter.python_func_kw_matches): Added
 	new matcher (it goes at the end of the priority list) to do
 	tab-completion on named function arguments.  Submitted by George
 	Sakkis <gsakkis-AT-eden.rutgers.edu>.  See the thread at
 	http://www.scipy.net/pipermail/ipython-dev/2005-April/000436.html
 	for more details.
 
 	* IPython/Magic.py (magic_run): Added new -e flag to ignore
 	SystemExit exceptions in the script being run.  Thanks to a report
 	by danny shevitz <danny_shevitz-AT-yahoo.com>, about this
 	producing very annoying behavior when running unit tests.
 
 2005-05-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): fixed auto-quoting and parens,
 	which I'd broken (again) due to a changed regexp.  In the process,
 	added ';' as an escape to auto-quote the whole line without
 	splitting its arguments.  Thanks to a report by Jerry McRae
 	<qrs0xyc02-AT-sneakemail.com>.
 
 	* IPython/ultraTB.py (VerboseTB.text): protect against rare but
 	possible crashes caused by a TokenError.  Reported by Ed Schofield
 	<schofield-AT-ftw.at>.
 	
 2005-05-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (hijack_wx): Fix to work with WX v.2.6.
 
 2005-04-29  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellQt): Thanks to Denis Rivière
 	<nudz-AT-free.fr>, Yann Cointepas <yann-AT-sapetnioc.org> and Benjamin
 	Thyreau <Benji2-AT-decideur.info>, we now have a -qthread option
 	which provides support for Qt interactive usage (similar to the
 	existing one for WX and GTK).  This had been often requested.
 
 2005-04-14  *** Released version 0.6.13
 
 2005-04-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): remove docstring evaluation
 	from _ofind, which gets called on almost every input line.  Now,
 	we only try to get docstrings if they are actually going to be
 	used (the overhead of fetching unnecessary docstrings can be
 	noticeable for certain objects, such as Pyro proxies).
 
 	* IPython/iplib.py (MagicCompleter.python_matches): Change the API
 	for completers.  For some reason I had been passing them the state
 	variable, which completers never actually need, and was in
 	conflict with the rlcompleter API.  Custom completers ONLY need to
 	take the text parameter.
 
 	* IPython/Extensions/InterpreterExec.py: Fix regexp so that magics
 	work correctly in pysh.  I've also moved all the logic which used
 	to be in pysh.py here, which will prevent problems with future
 	upgrades.  However, this time I must warn users to update their
 	pysh profile to include the line
 
 	import_all IPython.Extensions.InterpreterExec
 
 	because otherwise things won't work for them.  They MUST also
 	delete pysh.py and the line
 
 	execfile pysh.py
 
 	from their ipythonrc-pysh.
 
 	* IPython/FlexCompleter.py (Completer.attr_matches): Make more
 	robust in the face of objects whose dir() returns non-strings
 	(which it shouldn't, but some broken libs like ITK do).  Thanks to
 	a patch by John Hunter (implemented differently, though).  Also
 	minor improvements by using .extend instead of + on lists.
 
 	* pysh.py: 
 
 2005-04-06  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Make multi_line_specials on
 	by default, so that all users benefit from it.  Those who don't
 	want it can still turn it off.
 
 	* IPython/UserConfig/ipythonrc: Add multi_line_specials to the
 	config file, I'd forgotten about this, so users were getting it
 	off by default.
 
 	* IPython/iplib.py (ipmagic): big overhaul of the magic system for
 	consistency.  Now magics can be called in multiline statements,
 	and python variables can be expanded in magic calls via $var.
 	This makes the magic system behave just like aliases or !system
 	calls.
 
 2005-03-28  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): cleanup to use %s instead of
 	expensive string additions for building command.  Add support for
 	trailing ';' when autocall is used.
 
 2005-03-26  Fernando Perez  <[e-mail]>
 
 	* ipython.el: Fix http://www.scipy.net/roundup/ipython/issue31.
 	Bugfix by A. Schmolck, the ipython.el maintainer.  Also make
 	ipython.el robust against prompts with any number of spaces
 	(including 0) after the ':' character.
 
 	* IPython/Prompts.py (Prompt2.set_p_str): Fix spurious space in
 	continuation prompt, which misled users to think the line was
 	already indented.  Closes debian Bug#300847, reported to me by
 	Norbert Tretkowski <tretkowski-AT-inittab.de>.
 
 2005-03-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (Prompt1.__str__): Make sure that prompts are
 	properly aligned if they have embedded newlines.
 
 	* IPython/iplib.py (runlines): Add a public method to expose
 	IPython's code execution machinery, so that users can run strings
 	as if they had been typed at the prompt interactively.
 	(InteractiveShell.__init__): Added getoutput() to the __IPYTHON__
 	methods which can call the system shell, but with python variable
 	expansion.  The three such methods are: __IPYTHON__.system,
 	.getoutput and .getoutputerror.  These need to be documented in a
 	'public API' section (to be written) of the manual.
 
 2005-03-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.set_custom_exc): new system
 	for custom exception handling.  This is quite powerful, and it
 	allows for user-installable exception handlers which can trap
 	custom exceptions at runtime and treat them separately from
 	IPython's default mechanisms.  At the request of Frédéric
 	Mantegazza <mantegazza-AT-ill.fr>.
 	(InteractiveShell.set_custom_completer): public API function to
 	add new completers at runtime.
 
 2005-03-19  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (getdoc): Add a call to obj.getdoc(), to
 	allow objects which provide their docstrings via non-standard
 	mechanisms (like Pyro proxies) to still be inspected by ipython's
 	? system.
 
 	* IPython/iplib.py (InteractiveShell.__init__): back off the _o/_e
 	automatic capture system.  I tried quite hard to make it work
 	reliably, and simply failed.  I tried many combinations with the
 	subprocess module, but eventually nothing worked in all needed
 	cases (not blocking stdin for the child, duplicating stdout
 	without blocking, etc).  The new %sc/%sx still do capture to these
 	magical list/string objects which make shell use much more
 	conveninent, so not all is lost.
 
 	XXX - FIX MANUAL for the change above!
 
 	(runsource): I copied code.py's runsource() into ipython to modify
 	it a bit.  Now the code object and source to be executed are
 	stored in ipython.  This makes this info accessible to third-party
 	tools, like custom exception handlers.  After a request by Frédéric
 	Mantegazza <mantegazza-AT-ill.fr>.
 
 	* IPython/UserConfig/ipythonrc: Add up/down arrow keys to
 	history-search via readline (like C-p/C-n).  I'd wanted this for a
 	long time, but only recently found out how to do it.  For users
 	who already have their ipythonrc files made and want this, just
 	add:
 
 	readline_parse_and_bind "\e[A": history-search-backward
 	readline_parse_and_bind "\e[B": history-search-forward
 
 2005-03-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_sc): %sc and %sx now use the fancy
 	LSString and SList classes which allow transparent conversions
 	between list mode and whitespace-separated string.
 	(magic_r): Fix recursion problem in %r.
 
 	* IPython/genutils.py (LSString): New class to be used for
 	automatic storage of the results of all alias/system calls in _o
 	and _e (stdout/err).  These provide a .l/.list attribute which
 	does automatic splitting on newlines.  This means that for most
 	uses, you'll never need to do capturing of output with %sc/%sx
 	anymore, since ipython keeps this always done for you.  Note that
 	only the LAST results are stored, the _o/e variables are
 	overwritten on each call.  If you need to save their contents
 	further, simply bind them to any other name.
 
 2005-03-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (BasePrompt.cwd_filt): a few more fixes for
 	prompt namespace handling.
 
 2005-03-16  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (CachedOutput.__init__): Fix default and
 	classic prompts to be '>>> ' (final space was missing, and it
 	trips the emacs python mode).
 	(BasePrompt.__str__): Added safe support for dynamic prompt
 	strings.  Now you can set your prompt string to be '$x', and the
 	value of x will be printed from your interactive namespace.  The
 	interpolation syntax includes the full Itpl support, so
 	${foo()+x+bar()} is a valid prompt string now, and the function
 	calls will be made at runtime.
 
 2005-03-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_history): renamed %hist to %history, to
 	avoid name clashes in pylab.  %hist still works, it just forwards
 	the call to %history.
 
 2005-03-02  *** Released version 0.6.12
 
 2005-03-02  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_magic): log magic calls properly as
 	ipmagic() function calls.
 
 	* IPython/Magic.py (magic_time): Improved %time to support
 	statements and provide wall-clock as well as CPU time.
 
 2005-02-27  Fernando Perez  <[e-mail]>
 
 	* IPython/hooks.py: New hooks module, to expose user-modifiable
 	IPython functionality in a clean manner.  For now only the editor
 	hook is actually written, and other thigns which I intend to turn
 	into proper hooks aren't yet there.  The display and prefilter
 	stuff, for example, should be hooks.  But at least now the
 	framework is in place, and the rest can be moved here with more
 	time later.  IPython had had a .hooks variable for a long time for
 	this purpose, but I'd never actually used it for anything.
 
 2005-02-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): make the default ipython
 	directory be called _ipython under win32, to follow more the
 	naming peculiarities of that platform (where buggy software like
 	Visual Sourcesafe breaks with .named directories).  Reported by
 	Ville Vainio.
 
 2005-02-23  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): removed a few
 	auto_aliases for win32 which were causing problems.  Users can
 	define the ones they personally like.
 
 2005-02-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_time): new magic to time execution of
 	expressions.  After a request by Charles Moad <cmoad-AT-indiana.edu>.
 
 2005-02-19  Fernando Perez  <[e-mail]>
 
 	* IPython/ConfigLoader.py (ConfigLoader.load): Allow empty strings
 	into keys (for prompts, for example).
 
 	* IPython/Prompts.py (BasePrompt.set_p_str): Fix to allow empty
 	prompts in case users want them.  This introduces a small behavior
 	change: ipython does not automatically add a space to all prompts
 	anymore.  To get the old prompts with a space, users should add it
 	manually to their ipythonrc file, so for example prompt_in1 should
 	now read 'In [\#]: ' instead of 'In [\#]:'.
 	(BasePrompt.__init__): New option prompts_pad_left (only in rc
 	file) to control left-padding of secondary prompts.
 
 	* IPython/Magic.py (Magic.profile_missing_notice): Don't crash if
 	the profiler can't be imported.  Fix for Debian, which removed
 	profile.py because of License issues.  I applied a slightly
 	modified version of the original Debian patch at
 	http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=294500.
 
 2005-02-17  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (native_line_ends): Fix bug which would
 	cause improper line-ends under win32 b/c I was not opening files
 	in binary mode.  Bug report and fix thanks to Ville.
 
 	* IPython/iplib.py (handle_auto): Fix bug which I introduced when
 	trying to catch spurious foo[1] autocalls.  My fix actually broke
 	',/' autoquote/call with explicit escape (bad regexp).
 
 2005-02-15  *** Released version 0.6.11
 
 2005-02-14  Fernando Perez  <[e-mail]>
 
 	* IPython/background_jobs.py: New background job management
 	subsystem.  This is implemented via a new set of classes, and
 	IPython now provides a builtin 'jobs' object for background job
 	execution.  A convenience %bg magic serves as a lightweight
 	frontend for starting the more common type of calls.  This was
 	inspired by discussions with B. Granger and the BackgroundCommand
 	class described in the book Python Scripting for Computational
 	Science, by H. P. Langtangen: http://folk.uio.no/hpl/scripting
 	(although ultimately no code from this text was used, as IPython's
 	system is a separate implementation).
 
 	* IPython/iplib.py (MagicCompleter.python_matches): add new option
 	to control the completion of single/double underscore names
 	separately.  As documented in the example ipytonrc file, the
 	readline_omit__names variable can now be set to 2, to omit even
 	single underscore names.  Thanks to a patch by Brian Wong
 	<BrianWong-AT-AirgoNetworks.Com>.
 	(InteractiveShell.__init__): Fix bug which would cause foo[1] to
 	be autocalled as foo([1]) if foo were callable.  A problem for
 	things which are both callable and implement __getitem__.
 	(init_readline): Fix autoindentation for win32.  Thanks to a patch
 	by Vivian De Smedt <vivian-AT-vdesmedt.com>.
 
 2005-02-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Disabled the stout traps
 	which I had written long ago to sort out user error messages which
 	may occur during startup.  This seemed like a good idea initially,
 	but it has proven a disaster in retrospect.  I don't want to
 	change much code for now, so my fix is to set the internal 'debug'
 	flag to true everywhere, whose only job was precisely to control
 	this subsystem.  This closes issue 28 (as well as avoiding all
 	sorts of strange hangups which occur from time to time).
 
 2005-02-07  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_edit): Fix 'ed -p' not working when the
 	previous call produced a syntax error.
 
 	* IPython/OInspect.py (Inspector.pinfo): Fix crash when inspecting
 	classes without constructor.
 
 2005-02-06  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (MagicCompleter.complete): Extend the list of
 	completions with the results of each matcher, so we return results
 	to the user from all namespaces.  This breaks with ipython
 	tradition, but I think it's a nicer behavior.  Now you get all
 	possible completions listed, from all possible namespaces (python,
 	filesystem, magics...)  After a request by John Hunter
 	<jdhunter-AT-nitace.bsd.uchicago.edu>.
 
 2005-02-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_prun): Fix bug where prun would fail if
 	the call had quote characters in it (the quotes were stripped).
 
 2005-01-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): reduce reliance on
 	Itpl.itpl() to make the code more robust against psyco
 	optimizations.
 
 	* IPython/Itpl.py (Itpl.__str__): Use a _getframe() call instead
 	of causing an exception.  Quicker, cleaner.
 
 2005-01-28  Fernando Perez  <[e-mail]>
 
 	* scripts/ipython_win_post_install.py (install): hardcode
 	sys.prefix+'python.exe' as the executable path.  It turns out that
 	during the post-installation run, sys.executable resolves to the
 	name of the binary installer!  I should report this as a distutils
 	bug, I think.  I updated the .10 release with this tiny fix, to
 	avoid annoying the lists further.
 
 2005-01-27  *** Released version 0.6.10
 
 2005-01-27  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (norm): Added 'inf' as optional name for
 	L-infinity norm, included references to mathworld.com for vector
 	norm definitions.
 	(amin/amax): added amin/amax for array min/max.  Similar to what
 	pylab ships with after the recent reorganization of names.
 	(spike/spike_odd): removed deprecated spike/spike_odd functions.
 
 	* ipython.el: committed Alex's recent fixes and improvements.
 	Tested with python-mode from CVS, and it looks excellent.  Since
 	python-mode hasn't released anything in a while, I'm temporarily
 	putting a copy of today's CVS (v 4.70) of python-mode in:
 	  http://ipython.scipy.org/tmp/python-mode.el
 
 	* scripts/ipython_win_post_install.py (install): Win32 fix to use
 	sys.executable for the executable name, instead of assuming it's
 	called 'python.exe' (the post-installer would have produced broken
 	setups on systems with a differently named python binary).
 
 	* IPython/PyColorize.py (Parser.__call__): change explicit '\n'
 	references to os.linesep, to make the code more
 	platform-independent.  This is also part of the win32 coloring
 	fixes.
 
 	* IPython/genutils.py (page_dumb): Remove attempts to chop long
 	lines, which actually cause coloring bugs because the length of
 	the line is very difficult to correctly compute with embedded
 	escapes.  This was the source of all the coloring problems under
 	Win32.  I think that _finally_, Win32 users have a properly
 	working ipython in all respects.  This would never have happened
 	if not for Gary Bishop and Viktor Ransmayr's great help and work.
 
 2005-01-26  *** Released version 0.6.9
 
 2005-01-25  Fernando Perez  <[e-mail]>
 
 	* setup.py: finally, we have a true Windows installer, thanks to
 	the excellent work of Viktor Ransmayr
 	<viktor.ransmayr-AT-t-online.de>.  The docs have been updated for
 	Windows users.  The setup routine is quite a bit cleaner thanks to
 	this, and the post-install script uses the proper functions to
 	allow a clean de-installation using the standard Windows Control
 	Panel.
 	
 	* IPython/genutils.py (get_home_dir): changed to use the $HOME
 	environment variable under all OSes (including win32) if
 	available.  This will give consistency to win32 users who have set
 	this variable for any reason.  If os.environ['HOME'] fails, the
 	previous policy of using HOMEDRIVE\HOMEPATH kicks in.
 
 2005-01-24  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (empty_like): add empty_like(), similar to
 	zeros_like() but taking advantage of the new empty() Numeric routine.
 
 2005-01-23  *** Released version 0.6.8
 
 2005-01-22  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): I removed the
 	automatic show() calls.  After discussing things with JDH, it
 	turns out there are too many corner cases where this can go wrong.
 	It's best not to try to be 'too smart', and simply have ipython
 	reproduce as much as possible the default behavior of a normal
 	python shell.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Modified the
 	line-splitting regexp and _prefilter() to avoid calling getattr()
 	on assignments.  This closes
 	http://www.scipy.net/roundup/ipython/issue24.  Note that Python's
 	readline uses getattr(), so a simple <TAB> keypress is still
 	enough to trigger getattr() calls on an object.
 
 2005-01-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.magic_run): Fix the %run
 	docstring under pylab so it doesn't mask the original.
 
 2005-01-21  *** Released version 0.6.7
 
 2005-01-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MTInteractiveShell.runcode): Trap a crash with
 	signal handling for win32 users in multithreaded mode.
 
 2005-01-17  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (Inspector.pinfo): Fix crash when inspecting
 	instances with no __init__.  After a crash report by Norbert Nemec
 	<Norbert-AT-nemec-online.de>.
 
 2005-01-14  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix bug in reporting of
 	names for verbose exceptions, when multiple dotted names and the
 	'parent' object were present on the same line.
 
 2005-01-11  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (flag_calls): new utility to trap and flag
 	calls in functions.  I need it to clean up matplotlib support.
 	Also removed some deprecated code in genutils.
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): small fix so
 	that matplotlib scripts called with %run, which don't call show()
 	themselves, still have their plotting windows open.
 
 2005-01-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.__init__): Patch by Andrew Straw
 	<astraw-AT-caltech.edu>, to fix gtk deprecation warnings.
 
 2004-12-19  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MTInteractiveShell.runcode): Get rid of
 	parent_runcode, which was an eyesore.  The same result can be
 	obtained with Python's regular superclass mechanisms.
 
 2004-12-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_sc): Fix quote stripping problem
 	reported by Prabhu.
 	(Magic.magic_sx): direct all errors to Term.cerr (defaults to
 	sys.stderr) instead of explicitly calling sys.stderr.  This helps
 	maintain our I/O abstractions clean, for future GUI embeddings.
 
 	* IPython/genutils.py (info): added new utility for sys.stderr
 	unified info message handling (thin wrapper around warn()).
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix misreported global
 	composite (dotted) names on verbose exceptions.
 	(VerboseTB.nullrepr): harden against another kind of errors which
 	Python's inspect module can trigger, and which were crashing
 	IPython.  Thanks to a report by Marco Lombardi
 	<mlombard-AT-ma010192.hq.eso.org>.
 
 2004-12-13  *** Released version 0.6.6
 
 2004-12-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): catch RuntimeErrors
 	generated by pygtk upon initialization if it was built without
 	threads (for matplotlib users).  After a crash reported by
 	Leguijt, Jaap J SIEP-EPT-RES <Jaap.Leguijt-AT-shell.com>.
 
 	* IPython/ipmaker.py (make_IPython): fix small bug in the
 	import_some parameter for multiple imports.
 
 	* IPython/iplib.py (ipmagic): simplified the interface of
 	ipmagic() to take a single string argument, just as it would be
 	typed at the IPython cmd line.
 	(ipalias): Added new ipalias() with an interface identical to
 	ipmagic().  This completes exposing a pure python interface to the
 	alias and magic system, which can be used in loops or more complex
 	code where IPython's automatic line mangling is not active.
 
 	* IPython/genutils.py (timing): changed interface of timing to
 	simply run code once, which is the most common case.  timings()
 	remains unchanged, for the cases where you want multiple runs.
 
 	* IPython/Shell.py (MatplotlibShellBase._matplotlib_config): Fix a
 	bug where Python2.2 crashes with exec'ing code which does not end
 	in a single newline.  Python 2.3 is OK, so I hadn't noticed this
 	before.
 
 2004-12-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): changed name of option from
 	-t to -T, to accomodate the new -t flag in %run (the %run and
 	%prun options are kind of intermixed, and it's not easy to change
 	this with the limitations of python's getopt).
 
 	* IPython/Magic.py (Magic.magic_run): Added new -t option to time
 	the execution of scripts.  It's not as fine-tuned as timeit.py,
 	but it works from inside ipython (and under 2.2, which lacks
 	timeit.py).  Optionally a number of runs > 1 can be given for
 	timing very short-running code.
 
 	* IPython/genutils.py (uniq_stable): new routine which returns a
 	list of unique elements in any iterable, but in stable order of
 	appearance.  I needed this for the ultraTB fixes, and it's a handy
 	utility.
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix proper reporting of
 	dotted names in Verbose exceptions.  This had been broken since
 	the very start, now x.y will properly be printed in a Verbose
 	traceback, instead of x being shown and y appearing always as an
 	'undefined global'.  Getting this to work was a bit tricky,
 	because by default python tokenizers are stateless.  Saved by
 	python's ability to easily add a bit of state to an arbitrary
 	function (without needing to build a full-blown callable object).
 
 	Also big cleanup of this code, which had horrendous runtime
 	lookups of zillions of attributes for colorization.  Moved all
 	this code into a few templates, which make it cleaner and quicker.
 
 	Printout quality was also improved for Verbose exceptions: one
 	variable per line, and memory addresses are printed (this can be
 	quite handy in nasty debugging situations, which is what Verbose
 	is for).
 
 	* IPython/ipmaker.py (make_IPython): Do NOT execute files named in
 	the command line as scripts to be loaded by embedded instances.
 	Doing so has the potential for an infinite recursion if there are
 	exceptions thrown in the process.  This fixes a strange crash
 	reported by Philippe MULLER <muller-AT-irit.fr>.
 
 2004-12-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.use): Change pylab support
 	to reflect new names in matplotlib, which now expose the
 	matlab-compatible interface via a pylab module instead of the
 	'matlab' name.  The new code is backwards compatible, so users of
 	all matplotlib versions are OK.  Patch by J. Hunter.
 
 	* IPython/OInspect.py (Inspector.pinfo): Add to object? printing
 	of __init__ docstrings for instances (class docstrings are already
 	automatically printed).  Instances with customized docstrings
 	(indep. of the class) are also recognized and all 3 separate
 	docstrings are printed (instance, class, constructor).  After some
 	comments/suggestions by J. Hunter.
 
 2004-12-05  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (MagicCompleter.complete): Remove annoying
 	warnings when tab-completion fails and triggers an exception.
 
 2004-12-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_prun): Fix bug where an exception would
 	be triggered when using 'run -p'.  An incorrect option flag was
 	being set ('d' instead of 'D').
 	(manpage): fix missing escaped \- sign.
 
 2004-11-30  *** Released version 0.6.5
 
 2004-11-30  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_run): Fix bug in breakpoint
 	setting with -d option.
 
 	* setup.py (docfiles): Fix problem where the doc glob I was using
 	was COMPLETELY BROKEN.  It was giving the right files by pure
 	accident, but failed once I tried to include ipython.el.  Note:
 	glob() does NOT allow you to do exclusion on multiple endings!
 
 2004-11-29  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): cleaned up usage docstring, by using
 	the manpage as the source.  Better formatting & consistency.
 
 	* IPython/Magic.py (magic_run): Added new -d option, to run
 	scripts under the control of the python pdb debugger.  Note that
 	this required changing the %prun option -d to -D, to avoid a clash
 	(since %run must pass options to %prun, and getopt is too dumb to
 	handle options with string values with embedded spaces).  Thanks
 	to a suggestion by Matthew Arnison <maffew-AT-cat.org.au>.
 	(magic_who_ls): added type matching to %who and %whos, so that one
 	can filter their output to only include variables of certain
 	types.  Another suggestion by Matthew.
 	(magic_whos): Added memory summaries in kb and Mb for arrays.
 	(magic_who): Improve formatting (break lines every 9 vars).
 
 2004-11-28  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): Fix bug in syncing the input
 	cache when empty lines were present.
 
 2004-11-24  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): document the re-activated threading
 	options for WX and GTK.
 
 2004-11-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (start): Added Prabhu's big patch to reactivate
 	the -wthread and -gthread options, along with a new -tk one to try
 	and coordinate Tk threading with wx/gtk.  The tk support is very
 	platform dependent, since it seems to require Tcl and Tk to be
 	built with threads (Fedora1/2 appears NOT to have it, but in
 	Prabhu's Debian boxes it works OK).  But even with some Tk
 	limitations, this is a great improvement.
 
 	* IPython/Prompts.py (prompt_specials_color): Added \t for time
 	info in user prompts.  Patch by Prabhu.
 
 2004-11-18  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (ask_yes_no): Add check for a max of 20
 	EOFErrors and bail, to avoid infinite loops if a non-terminating
 	file is fed into ipython.  Patch submitted in issue 19 by user,
 	many thanks.
 
 	* IPython/iplib.py (InteractiveShell.handle_auto): do NOT trigger
 	autoquote/parens in continuation prompts, which can cause lots of
 	problems.  Closes roundup issue 20.
 
 2004-11-17  Fernando Perez  <[e-mail]>
 
 	* debian/control (Build-Depends-Indep): Fix dpatch dependency,
 	reported as debian bug #280505.  I'm not sure my local changelog
 	entry has the proper debian format (Jack?).
 
 2004-11-08  *** Released version 0.6.4
 
 2004-11-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (init_readline): Fix exit message for Windows
 	when readline is active.  Thanks to a report by Eric Jones
 	<eric-AT-enthought.com>.
 
 2004-11-07  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): Add a trap for OSError exceptions,
 	sometimes seen by win2k/cygwin users.
 
 2004-11-06  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (interact): Change the handling of %Exit from
 	trying to propagate a SystemExit to an internal ipython flag.
 	This is less elegant than using Python's exception mechanism, but
 	I can't get that to work reliably with threads, so under -pylab
 	%Exit was hanging IPython.  Cross-thread exception handling is
 	really a bitch.  Thaks to a bug report by Stephen Walton
 	<stephen.walton-AT-csun.edu>.
 
 2004-11-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (raw_input_original): store a pointer to the
 	true raw_input to harden against code which can modify it
 	(wx.py.PyShell does this and would otherwise crash ipython).
 	Thanks to a bug report by Jim Flowers <james.flowers-AT-lgx.com>.
 
 	* IPython/Shell.py (MTInteractiveShell.runsource): Cleaner fix for
 	Ctrl-C problem, which does not mess up the input line.
 
 2004-11-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Release.py: Changed licensing to BSD, in all files.
 	(name): lowercase name for tarball/RPM release.
 
 	* IPython/OInspect.py (getdoc): wrap inspect.getdoc() safely for
 	use throughout ipython.
 
 	* IPython/Magic.py (Magic._ofind): Switch to using the new
 	OInspect.getdoc() function.
 
 	* IPython/Shell.py (sigint_handler): Hack to ignore the execution
 	of the line currently being canceled via Ctrl-C.  It's extremely
 	ugly, but I don't know how to do it better (the problem is one of
 	handling cross-thread exceptions).
 
 2004-10-28  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (signal_handler): add signal handlers to trap
 	SIGINT and SIGSEGV in threaded code properly.  Thanks to a bug
 	report by Francesc Alted.
 
 2004-10-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Fix @
 	to % for pysh syntax extensions.
 
 2004-10-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_whos): modify output of Numeric
 	arrays to print a more useful summary, without calling str(arr).
 	This avoids the problem of extremely lengthy computations which
 	occur if arr is large, and appear to the user as a system lockup
 	with 100% cpu activity.  After a suggestion by Kristian Sandberg
 	<[e-mail]>.
 	(Magic.__init__): fix bug in global magic escapes not being
 	correctly set.
 
 2004-10-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (__license__): change to absolute imports of
 	ipython's own internal packages, to start adapting to the absolute
 	import requirement of PEP-328.
 
 	* IPython/genutils.py (__author__): Fix coding to utf-8 on all
 	files, and standardize author/license marks through the Release
 	module instead of having per/file stuff (except for files with
 	particular licenses, like the MIT/PSF-licensed codes).
 
 	* IPython/Debugger.py: remove dead code for python 2.1
 
 2004-10-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (ipmagic): New function for accessing magics
 	via a normal python function call.
 
 	* IPython/Magic.py (Magic.magic_magic): Change the magic escape
 	from '@' to '%', to accomodate the new @decorator syntax of python
 	2.4.
 
 2004-09-29  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.use): Added a wrapper to
 	matplotlib.use to prevent running scripts which try to switch
 	interactive backends from within ipython.  This will just crash
 	the python interpreter, so we can't allow it (but a detailed error
 	is given to the user).
 	
 2004-09-28  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec):
 	matplotlib-related fixes so that using @run with non-matplotlib
 	scripts doesn't pop up spurious plot windows.  This requires
 	matplotlib >= 0.63, where I had to make some changes as well.
 
 	* IPython/ipmaker.py (make_IPython): update version requirement to
 	python 2.2.
 
 	* IPython/iplib.py (InteractiveShell.mainloop): Add an optional
 	banner arg for embedded customization.
 
 	* IPython/Magic.py (Magic.__init__): big cleanup to remove all
 	explicit uses of __IP as the IPython's instance name.  Now things
 	are properly handled via the shell.name value.  The actual code
 	is a bit ugly b/c I'm doing it via a global in Magic.py, but this
 	is much better than before.  I'll clean things completely when the
 	magic stuff gets a real overhaul.
 
 	* ipython.1: small fixes, sent in by Jack Moffit.  He also sent in
 	minor changes to debian dir.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Fix adding a
 	pointer to the shell itself in the interactive namespace even when
 	a user-supplied dict is provided.  This is needed for embedding
 	purposes (found by tests with Michel Sanner).
 
 2004-09-27  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/ipythonrc: remove []{} from
 	readline_remove_delims, so that things like [modname.<TAB> do
 	proper completion.  This disables [].TAB, but that's a less common
 	case than module names in list comprehensions, for example.
 	Thanks to a report by Andrea Riciputi.
 
 2004-09-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): reorder to avoid
 	blocking problems in win32 and osx.  Fix by John.
 
 2004-09-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.OnInit): Fix output redirection bug
 	for Win32 and OSX.  Fix by John Hunter.
 
 2004-08-30  *** Released version 0.6.3
 
 2004-08-30  Fernando Perez  <[e-mail]>
 
 	* setup.py (isfile): Add manpages to list of dependent files to be
 	updated.
 
 2004-08-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (start): I've disabled -wthread and -gthread
 	for now.  They don't really work with standalone WX/GTK code
 	(though matplotlib IS working fine with both of those backends).
 	This will neeed much more testing.  I disabled most things with
 	comments, so turning it back on later should be pretty easy.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Fix accidental
 	autocalling of expressions like r'foo', by modifying the line
 	split regexp.  Closes
 	http://www.scipy.net/roundup/ipython/issue18, reported by Nicholas
 	Riley <ipythonbugs-AT-sabi.net>.
 	(InteractiveShell.mainloop): honor --nobanner with banner
 	extensions.
 
 	* IPython/Shell.py: Significant refactoring of all classes, so
 	that we can really support ALL matplotlib backends and threading
 	models (John spotted a bug with Tk which required this).  Now we
 	should support single-threaded, WX-threads and GTK-threads, both
 	for generic code and for matplotlib.
 
 	* IPython/ipmaker.py (__call__): Changed -mpthread option to
 	-pylab, to simplify things for users.  Will also remove the pylab
 	profile, since now all of matplotlib configuration is directly
 	handled here.  This also reduces startup time.
 
 	* IPython/Shell.py (IPShellGTK.run): Fixed bug where mainloop() of
 	shell wasn't being correctly called.  Also in IPShellWX.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Added option to
 	fine-tune banner.
 
 	* IPython/numutils.py (spike): Deprecate these spike functions,
 	delete (long deprecated) gnuplot_exec handler.
 
 2004-08-26  Fernando Perez  <[e-mail]>
 
 	* ipython.1: Update for threading options, plus some others which
 	were missing.
 
 	* IPython/ipmaker.py (__call__): Added -wthread option for
 	wxpython thread handling.  Make sure threading options are only
 	valid at the command line.
 
 	* scripts/ipython: moved shell selection into a factory function
 	in Shell.py, to keep the starter script to a minimum.
 
 2004-08-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.wxexit): fixes to WX threading, by
 	John.  Along with some recent changes he made to matplotlib, the
 	next versions of both systems should work very well together.
 
 2004-08-24  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): cleanup some dead code.  I
 	tried to switch the profiling to using hotshot, but I'm getting
 	strange errors from prof.runctx() there.  I may be misreading the
 	docs, but it looks weird.  For now the profiling code will
 	continue to use the standard profiler.
 
 2004-08-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.__init__): Improvements to the WX
 	threaded shell, by John Hunter.  It's not quite ready yet, but
 	close.
 
 2004-08-22  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): tab cleanups, also
 	in Magic and ultraTB.
 
 	* ipython.1: document threading options in manpage.
 
 	* scripts/ipython: Changed name of -thread option to -gthread,
 	since this is GTK specific.  I want to leave the door open for a
 	-wthread option for WX, which will most likely be necessary.  This
 	change affects usage and ipmaker as well.
 
 	* IPython/Shell.py (matplotlib_shell): Add a factory function to
 	handle the matplotlib shell issues.  Code by John Hunter
 	<jdhunter-AT-nitace.bsd.uchicago.edu>.
 	(IPShellMatplotlibWX.__init__): Rudimentary WX support.  It's
 	broken (and disabled for end users) for now, but it puts the
 	infrastructure in place.
 
 2004-08-21  Fernando Perez  <[e-mail]>
 
 	* ipythonrc-pylab: Add matplotlib support.
 
 	* matplotlib_config.py: new files for matplotlib support, part of
 	the pylab profile.
 
 	* IPython/usage.py (__doc__): documented the threading options.
 
 2004-08-20  Fernando Perez  <[e-mail]>
 
 	* ipython: Modified the main calling routine to handle the -thread
 	and -mpthread options.  This needs to be done as a top-level hack,
 	because it determines which class to instantiate for IPython
 	itself.
 
 	* IPython/Shell.py (MTInteractiveShell.__init__): New set of
 	classes to support multithreaded GTK operation without blocking,
 	and matplotlib with all backends.  This is a lot of still very
 	experimental code, and threads are tricky.  So it may still have a
 	few rough edges...  This code owes a lot to
 	http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by
 	Brian # McErlean and John Finlay, to Antoon Pardon for fixes, and
 	to John Hunter for all the matplotlib work.
 
 	* IPython/ipmaker.py (__call__): Added -thread and -mpthread
 	options for gtk thread and matplotlib support.
 
 2004-08-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): don't trigger
 	autocall for things like p*q,p/q,p+q,p-q, when p is callable.  Bug
 	reported by Stephen Walton <stephen.walton-AT-csun.edu>.
 
 2004-08-11  Fernando Perez  <[e-mail]>
 
 	* setup.py (isfile): Fix build so documentation gets updated for
 	rpms (it was only done for .tgz builds).
 
 2004-08-10  Fernando Perez  <[e-mail]>
 
 	* genutils.py (Term): Fix misspell of stdin stream (sin->cin).
 
 	* iplib.py : Silence syntax error exceptions in tab-completion.
 	
 2004-08-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (Prompt2.set_colors): Fix incorrectly set
 	'color off' mark for continuation prompts.  This was causing long
 	continuation lines to mis-wrap.
 
 2004-08-01  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Allow the shell class used
 	for building ipython to be a parameter.  All this is necessary
 	right now to have a multithreaded version, but this insane
 	non-design will be cleaned up soon.  For now, it's a hack that
 	works.
 
 	* IPython/Shell.py (IPShell.__init__): Stop using mutable default
 	args in various places.  No bugs so far, but it's a dangerous
 	practice.
 
 2004-07-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (complete): ignore SyntaxError exceptions to
 	fix completion of files with dots in their names under most
 	profiles (pysh was OK because the completion order is different).
 
 2004-07-27  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): build dict of
 	keywords manually, b/c the one in keyword.py was removed in python
 	2.4.  Patch by Anakim Border <aborder-AT-users.sourceforge.net>.
 	This is NOT a bug under python 2.3 and earlier.
 
 2004-07-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): Add another
 	linecache.checkcache() call to try to prevent inspect.py from
 	crashing under python 2.3.  I think this fixes
 	http://www.scipy.net/roundup/ipython/issue17.
 
 2004-07-26  *** Released version 0.6.2
 
 2004-07-26  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_cd): Fix bug where 'cd -N' would
 	fail for any number.
 	(Magic.magic_bookmark): Fix bug where 'bookmark -l' would fail for
 	empty bookmarks.
 
 2004-07-26  *** Released version 0.6.1
 
 2004-07-26  Fernando Perez  <[e-mail]>
 
 	* ipython_win_post_install.py (run): Added pysh shortcut for Windows.
 
 	* IPython/iplib.py (protect_filename): Applied Ville's patch for
 	escaping '()[]{}' in filenames.
 
 	* IPython/Magic.py (shlex_split): Fix handling of '*' and '?' for
 	Python 2.2 users who lack a proper shlex.split.
 
 2004-07-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.init_readline): Add support
 	for reading readline's init file.  I follow the normal chain:
 	$INPUTRC is honored, otherwise ~/.inputrc is used.  Thanks to a
 	report by Mike Heeter.  This closes
 	http://www.scipy.net/roundup/ipython/issue16.
 
 2004-07-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (__init__): Add better handling of '\' under
 	Win32 for filenames.  After a patch by Ville.
 
 2004-07-17  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): fix bug where
 	autocalling would be triggered for 'foo is bar' if foo is
 	callable.  I also cleaned up the autocall detection code to use a
 	regexp, which is faster.  Bug reported by Alexander Schmolck.
 
 	* IPython/Magic.py (Magic.magic_pinfo): Fix bug where strings with
 	'?' in them would confuse the help system.  Reported by Alex
 	Schmolck.
 
 2004-07-16  Fernando Perez  <[e-mail]>
 
 	* IPython/GnuplotInteractive.py (__all__): added plot2.
 
 	* IPython/Gnuplot2.py (Gnuplot.plot2): added new function for
 	plotting dictionaries, lists or tuples of 1d arrays.
 
 	* IPython/Magic.py (Magic.magic_hist): small clenaups and
 	optimizations.
 
 	* IPython/iplib.py:Remove old Changelog info for cleanup.  This is
 	the information which was there from Janko's original IPP code:
 
 	03.05.99 20:53 porto.ifm.uni-kiel.de
 	--Started changelog.
 	--make clear do what it say it does
 	--added pretty output of lines from inputcache
 	--Made Logger a mixin class, simplifies handling of switches
 	--Added own completer class. .string<TAB> expands to last history
 	line which starts with string.  The new expansion is also present
 	with Ctrl-r from the readline library.  But this shows, who this
 	can be done for other cases.
 	--Added convention that all shell functions should accept a
 	parameter_string This opens the door for different behaviour for
 	each function. @cd is a good example of this.
 
 	04.05.99 12:12 porto.ifm.uni-kiel.de
 	--added logfile rotation
 	--added new mainloop method which freezes first the namespace
 
 	07.05.99 21:24 porto.ifm.uni-kiel.de
 	--added the docreader classes. Now there is a help system.
 	-This is only a first try. Currently it's not easy to put new
 	stuff in the indices. But this is the way to go. Info would be
 	better, but HTML is every where and not everybody has an info
 	system installed and it's not so easy to change html-docs to info.
 	--added global logfile option
 	--there is now a hook for object inspection method pinfo needs to
 	be provided for this. Can be reached by two '??'.
 
 	08.05.99 20:51 porto.ifm.uni-kiel.de
 	--added a README
 	--bug in rc file. Something has changed so functions in the rc
 	file need to reference the shell and not self. Not clear if it's a
 	bug or feature.
 	--changed rc file for new behavior
 
 2004-07-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): fixed recent bug where the input
 	cache was falling out of sync in bizarre manners when multi-line
 	input was present.  Minor optimizations and cleanup.
 
 	(Logger): Remove old Changelog info for cleanup.  This is the
 	information which was there from Janko's original code:
 
 	Changes to Logger: - made the default log filename a parameter
 
 	- put a check for lines beginning with !@? in log(). Needed
 	(even if the handlers properly log their lines) for mid-session
 	logging activation to work properly. Without this, lines logged
 	in mid session, which get read from the cache, would end up
 	'bare' (with !@? in the open) in the log. Now they are caught
 	and prepended with a #.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): added check
 	in case MagicCompleter fails to be defined, so we don't crash.
 
 2004-07-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (Gnuplot.hardcopy): add automatic generation
 	of EPS if the requested filename ends in '.eps'.
 
 2004-07-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_escape): Fix
 	escaping of quotes when calling the shell.
 
 2004-07-02  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (CachedOutput.update): Fix problem with
 	gettext not working because we were clobbering '_'.  Fixes
 	http://www.scipy.net/roundup/ipython/issue6.
 
 2004-07-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_cd): integrated bookmark handling
 	into @cd.  Patch by Ville.
 
 	* IPython/iplib.py (InteractiveShell.post_config_initialization):
 	new function to store things after ipmaker runs.  Patch by Ville.
 	Eventually this will go away once ipmaker is removed and the class
 	gets cleaned up, but for now it's ok.  Key functionality here is
 	the addition of the persistent storage mechanism, a dict for
 	keeping data across sessions (for now just bookmarks, but more can
 	be implemented later).
 
 	* IPython/Magic.py (Magic.magic_bookmark): New bookmark system,
 	persistent across sections.  Patch by Ville, I modified it
 	soemwhat to allow bookmarking arbitrary dirs other than CWD.  Also
 	added a '-l' option to list all bookmarks.
 
 	* IPython/iplib.py (InteractiveShell.atexit_operations): new
 	center for cleanup.  Registered with atexit.register().  I moved
 	here the old exit_cleanup().  After a patch by Ville.
 
 	* IPython/Magic.py (get_py_filename): added '~' to the accepted
 	characters in the hacked shlex_split for python 2.2.
 
 	* IPython/iplib.py (file_matches): more fixes to filenames with
 	whitespace in them.  It's not perfect, but limitations in python's
 	readline make it impossible to go further.
 
 2004-06-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (file_matches): escape whitespace correctly in
 	filename completions.  Bug reported by Ville.
 
 2004-06-28  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (__call__): Added per-profile histories.  Now
 	the history file will be called 'history-PROFNAME' (or just
 	'history' if no profile is loaded).  I was getting annoyed at
 	getting my Numerical work history clobbered by pysh sessions.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Internal
 	getoutputerror() function so that we can honor the system_verbose
 	flag for _all_ system calls.  I also added escaping of #
 	characters here to avoid confusing Itpl.
 
 	* IPython/Magic.py (shlex_split): removed call to shell in
 	parse_options and replaced it with shlex.split().  The annoying
 	part was that in Python 2.2, shlex.split() doesn't exist, so I had
 	to backport it from 2.3, with several frail hacks (the shlex
 	module is rather limited in 2.2).  Thanks to a suggestion by Ville
 	Vainio <[e-mail]>.  For Python 2.3 there should be no
 	problem.
 	
 	(Magic.magic_system_verbose): new toggle to print the actual
 	system calls made by ipython.  Mainly for debugging purposes.
 
 	* IPython/GnuplotRuntime.py (gnu_out): fix bug for cygwin, which
 	doesn't support persistence.  Reported (and fix suggested) by
 	Travis Caldwell <[e-mail]>.
 
 2004-06-26  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): fix to handle correctly empty
 	continue prompts.
 
 	* IPython/Extensions/InterpreterExec.py (pysh): moved the pysh()
 	function (basically a big docstring) and a few more things here to
 	speedup startup. pysh.py is now very lightweight.  We want because
 	it gets execfile'd, while InterpreterExec gets imported, so
 	byte-compilation saves time.
 
 2004-06-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_cd): Fixed to restore usage of 'cd
 	-NUM', which was recently broken.
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_escape): allow !
 	in multi-line input (but not !!, which doesn't make sense there).
 
 	* IPython/UserConfig/ipythonrc: made autoindent on by default.
 	It's just too useful, and people can turn it off in the less
 	common cases where it's a problem.
 
 2004-06-24  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): big change -
 	special syntaxes (like alias calling) is now allied in multi-line
 	input.  This is still _very_ experimental, but it's necessary for
 	efficient shell usage combining python looping syntax with system
 	calls.  For now it's restricted to aliases, I don't think it
 	really even makes sense to have this for magics.
 
 2004-06-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Added
 	$var=cmd <=> @sc var=cmd and  $$var=cmd <=> @sc -l var=cmd.
 
 	* IPython/Magic.py (Magic.magic_rehashx): modified to handle
 	extensions under Windows (after code sent by Gary Bishop).  The
 	extensions considered 'executable' are stored in IPython's rc
 	structure as win_exec_ext.
 
 	* IPython/genutils.py (shell): new function, like system() but
 	without return value.  Very useful for interactive shell work.
 
 	* IPython/Magic.py (Magic.magic_unalias): New @unalias function to
 	delete aliases.
 
 	* IPython/iplib.py (InteractiveShell.alias_table_update): make
 	sure that the alias table doesn't contain python keywords.
 
 2004-06-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_rehash): Fix crash when
 	non-existent items are found in $PATH.  Reported by Thorsten.
 
 2004-06-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (complete): modified the completer so that the
 	order of priorities can be easily changed at runtime.
 
 	* IPython/Extensions/InterpreterExec.py (prefilter_shell):
 	Modified to auto-execute all lines beginning with '~', '/' or '.'.
 
 	* IPython/Magic.py (Magic.magic_sx): modified @sc and @sx to
 	expand Python variables prepended with $ in all system calls.  The
 	same was done to InteractiveShell.handle_shell_escape.  Now all
 	system access mechanisms (!, !!, @sc, @sx and aliases) allow the
 	expansion of python variables and expressions according to the
 	syntax of PEP-215 - http://www.python.org/peps/pep-0215.html.
 
 	Though PEP-215 has been rejected, a similar (but simpler) one
 	seems like it will go into Python 2.4, PEP-292 -
 	http://www.python.org/peps/pep-0292.html.
 
 	I'll keep the full syntax of PEP-215, since IPython has since the
 	start used Ka-Ping Yee's reference implementation discussed there
 	(Itpl), and I actually like the powerful semantics it offers.
 
 	In order to access normal shell variables, the $ has to be escaped
 	via an extra $.  For example:
 
 	In [7]: PATH='a python variable'
 
 	In [8]: !echo $PATH
 	a python variable
 
 	In [9]: !echo $$PATH
 	/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
 
 	(Magic.parse_options): escape $ so the shell doesn't evaluate
 	things prematurely.
 
 	* IPython/iplib.py (InteractiveShell.call_alias): added the
 	ability for aliases to expand python variables via $.
 
 	* IPython/Magic.py (Magic.magic_rehash): based on the new alias
 	system, now there's a @rehash/@rehashx pair of magics.  These work
 	like the csh rehash command, and can be invoked at any time.  They
 	build a table of aliases to everything in the user's $PATH
 	(@rehash uses everything, @rehashx is slower but only adds
 	executable files).  With this, the pysh.py-based shell profile can
 	now simply call rehash upon startup, and full access to all
 	programs in the user's path is obtained.
 
 	* IPython/iplib.py (InteractiveShell.call_alias): The new alias
 	functionality is now fully in place.  I removed the old dynamic
 	code generation based approach, in favor of a much lighter one
 	based on a simple dict.  The advantage is that this allows me to
 	now have thousands of aliases with negligible cost (unthinkable
 	with the old system).
 
 2004-06-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (__init__): extended MagicCompleter class to
 	also complete (last in priority) on user aliases.
 
 	* IPython/Itpl.py (Itpl.__str__): fixed order of globals/locals in
 	call to eval.
 	(ItplNS.__init__): Added a new class which functions like Itpl,
 	but allows configuring the namespace for the evaluation to occur
 	in.
 
 2004-06-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.runcode): modify to print a
 	better message when 'exit' or 'quit' are typed (a common newbie
 	confusion).
 
 	* IPython/Magic.py (Magic.magic_colors): Added the runtime color
 	check for Windows users.
 
 	* IPython/iplib.py (InteractiveShell.user_setup): removed
 	disabling of colors for Windows.  I'll test at runtime and issue a
 	warning if Gary's readline isn't found, as to nudge users to
 	download it.
 
 2004-06-16  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Stream.__init__): changed to print errors
 	to sys.stderr.  I had a circular dependency here.  Now it's
 	possible to run ipython as IDLE's shell (consider this pre-alpha,
 	since true stdout things end up in the starting terminal instead
 	of IDLE's out).
 
 	* IPython/Prompts.py (Prompt2.set_colors): prevent crashes for
 	users who haven't # updated their prompt_in2 definitions.  Remove
 	eventually.
 	(multiple_replace): added credit to original ASPN recipe.
 
 2004-06-15  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): add 'cp' to the
 	list of auto-defined aliases.
 
 2004-06-13  Fernando Perez  <[e-mail]>
 
 	* setup.py (scriptfiles): Don't trigger win_post_install unless an
 	install was really requested (so setup.py can be used for other
 	things under Windows).
 
 2004-06-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): Manually remove any old
 	backup, since os.remove may fail under Windows.  Fixes bug
 	reported by Thorsten.
 
 2004-06-09  Fernando Perez  <[e-mail]>
 
 	* examples/example-embed.py: fixed all references to %n (replaced
 	with \\# for ps1/out prompts and with \\D for ps2 prompts).  Done
 	for all examples and the manual as well.
 
 2004-06-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (Prompt2.set_p_str): fixed all prompt
 	alignment and color management.  All 3 prompt subsystems now
 	inherit from BasePrompt.
 
 	* tools/release: updates for windows installer build and tag rpms
 	with python version (since paths are fixed).
 
 	* IPython/UserConfig/ipythonrc: modified to use \# instead of %n,
 	which will become eventually obsolete.  Also fixed the default
 	prompt_in2 to use \D, so at least new users start with the correct
 	defaults.
 	WARNING: Users with existing ipythonrc files will need to apply
 	this fix manually!
 
 	* setup.py: make windows installer (.exe).  This is finally the
 	integration of an old patch by Cory Dodt <dodt-AT-fcoe.k12.ca.us>,
 	which I hadn't included because it required Python 2.3 (or recent
 	distutils).
 
 	* IPython/usage.py (__doc__): update docs (and manpage) to reflect
 	usage of new '\D' escape.
 
 	* IPython/Prompts.py (ROOT_SYMBOL): Small fix for Windows (which
 	lacks os.getuid())
 	(CachedOutput.set_colors): Added the ability to turn coloring
 	on/off with @colors even for manually defined prompt colors.  It
 	uses a nasty global, but it works safely and via the generic color
 	handling mechanism.
 	(Prompt2.__init__): Introduced new escape '\D' for continuation
 	prompts. It represents the counter ('\#') as dots.
 	*** NOTE *** THIS IS A BACKWARDS-INCOMPATIBLE CHANGE.  Users will
 	need to update their ipythonrc files and replace '%n' with '\D' in
 	their prompt_in2 settings everywhere.  Sorry, but there's
 	otherwise no clean way to get all prompts to properly align.  The
 	ipythonrc shipped with IPython has been updated.
 
 2004-06-07  Fernando Perez  <[e-mail]>
 
 	* setup.py (isfile): Pass local_icons option to latex2html, so the
 	resulting HTML file is self-contained.  Thanks to
 	dryice-AT-liu.com.cn for the tip.
 
 	* pysh.py: I created a new profile 'shell', which implements a
 	_rudimentary_ IPython-based shell.  This is in NO WAY a realy
 	system shell, nor will it become one anytime soon.  It's mainly
 	meant to illustrate the use of the new flexible bash-like prompts.
 	I guess it could be used by hardy souls for true shell management,
 	but it's no tcsh/bash...  pysh.py is loaded by the 'shell'
 	profile.  This uses the InterpreterExec extension provided by
 	W.J. van der Laan <gnufnork-AT-hetdigitalegat.nl>
 
 	* IPython/Prompts.py (PromptOut.__str__): now it will correctly
 	auto-align itself with the length of the previous input prompt
 	(taking into account the invisible color escapes).
 	(CachedOutput.__init__): Large restructuring of this class.  Now
 	all three prompts (primary1, primary2, output) are proper objects,
 	managed by the 'parent' CachedOutput class.  The code is still a
 	bit hackish (all prompts share state via a pointer to the cache),
 	but it's overall far cleaner than before.
 
 	* IPython/genutils.py (getoutputerror): modified to add verbose,
 	debug and header options.  This makes the interface of all getout*
 	functions uniform.
 	(SystemExec.getoutputerror): added getoutputerror to SystemExec.
 
 	* IPython/Magic.py (Magic.default_option): added a function to
 	allow registering default options for any magic command.  This
 	makes it easy to have profiles which customize the magics globally
 	for a certain use.  The values set through this function are
 	picked up by the parse_options() method, which all magics should
 	use to parse their options.
 
 	* IPython/genutils.py (warn): modified the warnings framework to
 	use the Term I/O class.  I'm trying to slowly unify all of
 	IPython's I/O operations to pass through Term.
 
 	* IPython/Prompts.py (Prompt2._str_other): Added functionality in
 	the secondary prompt to correctly match the length of the primary
 	one for any prompt.  Now multi-line code will properly line up
 	even for path dependent prompts, such as the new ones available
 	via the prompt_specials.
 
 2004-06-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (prompt_specials): Added the ability to have
 	bash-like special sequences in the prompts, which get
 	automatically expanded.  Things like hostname, current working
 	directory and username are implemented already, but it's easy to
 	add more in the future.  Thanks to a patch by W.J. van der Laan
 	<gnufnork-AT-hetdigitalegat.nl>
 	(prompt_specials): Added color support for prompt strings, so
 	users can define arbitrary color setups for their prompts.
 
 2004-06-05  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Term.reopen_all): Added Windows-specific
 	code to load Gary Bishop's readline and configure it
 	automatically.  Thanks to Gary for help on this.
 
 2004-06-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): fix bug for logging
 	with no filename (previous fix was incomplete).
 
 2004-05-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.parse_options): fix bug where naked
 	parens would get passed to the shell.
 
 2004-05-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): changed default profile
 	sort order to 'time' (the more common profiling need).
 
 	* IPython/OInspect.py (Inspector.pinfo): flush the inspect cache
 	so that source code shown is guaranteed in sync with the file on
 	disk (also changed in psource).  Similar fix to the one for
 	ultraTB on 2004-05-06.  Thanks to a bug report by Yann Le Du
 	<yann.ledu-AT-noos.fr>.
 	
 	* IPython/Magic.py (Magic.parse_options): Fixed bug where commands
 	with a single option would not be correctly parsed. Closes
 	http://www.scipy.net/roundup/ipython/issue14.  This bug had been
 	introduced in 0.6.0 (on 2004-05-06).
 
 2004-05-13  *** Released version 0.6.0
 
 2004-05-13  Fernando Perez  <[e-mail]>
 
 	* debian/: Added debian/ directory to CVS, so that debian support
 	is publicly accessible.  The debian package is maintained by Jack
 	Moffit <jack-AT-xiph.org>.
 
 	* Documentation: included the notes about an ipython-based system
 	shell (the hypothetical 'pysh') into the new_design.pdf document,
 	so that these ideas get distributed to users along with the
 	official documentation.
 
 2004-05-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): fix recently introduced
 	bug (misindented line) where logstart would fail when not given an
 	explicit filename.
 
 2004-05-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.parse_options): skip system call when
 	there are no options to look for.  Faster, cleaner for the common
 	case.
 
 	* Documentation: many updates to the manual: describing Windows
 	support better, Gnuplot updates, credits, misc small stuff.  Also
 	updated the new_design doc a bit.
 
 2004-05-06  *** Released version 0.6.0.rc1
 
 2004-05-06  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (ListTB.text): modified a ton of string +=
 	operations to use the vastly more efficient list/''.join() method.
 	(FormattedTB.text): Fix
 	http://www.scipy.net/roundup/ipython/issue12 - exception source
 	extract not updated after reload.  Thanks to Mike Salib
 	<msalib-AT-mit.edu> for pinning the source of the problem.
 	Fortunately, the solution works inside ipython and doesn't require
 	any changes to python proper.
 
 	* IPython/Magic.py (Magic.parse_options): Improved to process the
 	argument list as a true shell would (by actually using the
 	underlying system shell).  This way, all @magics automatically get
 	shell expansion for variables.  Thanks to a comment by Alex
 	Schmolck.
 
 2004-04-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): Added a special
 	trap for a debugger quit exception, which is basically impossible
 	to handle by normal mechanisms, given what pdb does to the stack.
 	This fixes a crash reported by <fgibbons-AT-llama.med.harvard.edu>.
 
 2004-04-03  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Term): Standardized the names of the Term
 	class streams to cin/cout/cerr, following C++ naming conventions
 	(I can't use in/out/err because 'in' is not a valid attribute
 	name).
 
 	* IPython/iplib.py (InteractiveShell.interact): don't increment
 	the prompt if there's no user input.  By Daniel 'Dang' Griffith
 	<pythondev-dang-AT-lazytwinacres.net>, after a suggestion from
 	Francois Pinard.
 
 2004-04-02  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Stream.__init__): Modified to survive at
 	least importing in contexts where stdin/out/err aren't true file
 	objects, such as PyCrust (they lack fileno() and mode).  However,
 	the recovery facilities which rely on these things existing will
 	not work.
 
 2004-04-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_sx): modified (as well as @sc) to
 	use the new getoutputerror() function, so it properly
 	distinguishes stdout/err.
 
 	* IPython/genutils.py (getoutputerror): added a function to
 	capture separately the standard output and error of a command.
 	After a comment from dang on the mailing lists.  This code is
 	basically a modified version of commands.getstatusoutput(), from
 	the standard library.
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_escape): added
 	'!!' as a special syntax (shorthand) to access @sx.
 
 	* IPython/Magic.py (Magic.magic_sx): new magic, to execute a shell
 	command and return its output as a list split on '\n'.
 
 2004-03-31  Fernando Perez  <[e-mail]>
 
 	* IPython/FakeModule.py (FakeModule.__init__): added __nonzero__
 	method to dictionaries used as FakeModule instances if they lack
 	it.  At least pydoc in python2.3 breaks for runtime-defined
 	functions without this hack.  At some point I need to _really_
 	understand what FakeModule is doing, because it's a gross hack.
 	But it solves Arnd's problem for now...
 
 2004-02-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): Fix bug where 'rotate'
 	mode would behave erratically.  Also increased the number of
 	possible logs in rotate mod to 999.  Thanks to Rod Holland
 	<[e-mail]> for the report and fixes.
 	
 2004-02-26  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): Check that the curses module really
 	has the initscr attribute before trying to use it.  For some
 	reason, the Solaris curses module is missing this.  I think this
 	should be considered a Solaris python bug, but I'm not sure.
 
 2004-01-17  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Stream.__init__): Changes to try to make
 	ipython robust against stdin/out/err being closed by the user.
 	This is 'user error' (and blocks a normal python session, at least
 	the stdout case).  However, Ipython should be able to survive such
 	instances of abuse as gracefully as possible.  To simplify the
 	coding and maintain compatibility with Gary Bishop's Term
 	contributions, I've made use of classmethods for this.  I think
 	this introduces a dependency on python 2.2.
 
 2004-01-13  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (exp_safe): simplified the code a bit and
 	removed the need for importing the kinds module altogether.
 
 2004-01-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_sc): Made the shell capture system
 	a magic function instead, after some community feedback.  No
 	special syntax will exist for it, but its name is deliberately
 	very short.
 
 2003-12-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_assign): Added
 	new functionality, to automagically assign the result of a shell
 	command to a variable.  I'll solicit some community feedback on
 	this before making it permanent.
 
 	* IPython/OInspect.py (Inspector.pinfo): Fix crash when info was
 	requested about callables for which inspect couldn't obtain a
 	proper argspec.  Thanks to a crash report sent by Etienne
 	Posthumus <etienne-AT-apple01.cs.vu.nl>.
 
 2003-12-09  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): patch for the pager to work across
 	various versions of Windows.  By Gary Bishop.
 
 2003-12-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (PlotItems): Fixes for working with
 	Gnuplot.py version 1.7, whose internal names changed quite a bit.
 	While I tested this and it looks ok, there may still be corner
 	cases I've missed.
 
 2003-12-01  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Fixed a bug
 	where a line like 'p,q=1,2' would fail because the automagic
 	system would be triggered for @p.
 
 	* IPython/DPyGetOpt.py (DPyGetOpt.processArguments): Tab-related
 	cleanups, code unmodified.
 
 	* IPython/genutils.py (Term): added a class for IPython to handle
 	output.  In most cases it will just be a proxy for stdout/err, but
 	having this allows modifications to be made for some platforms,
 	such as handling color escapes under Windows.  All of this code
 	was contributed by Gary Bishop, with minor modifications by me.
 	The actual changes affect many files.
 
 2003-11-30  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (file_matches): new completion code, courtesy
 	of Jeff Collins.  This enables filename completion again under
 	python 2.3, which disabled it at the C level.
 
 2003-11-11  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (amap): Added amap() fn.  Simple shorthand
 	for Numeric.array(map(...)), but often convenient.
 
 2003-11-05  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (frange): Changed a call from int() to
 	int(round()) to prevent a problem reported with arange() in the
 	numpy list.
 
 2003-10-06  Fernando Perez  <[e-mail]>
 
 	* IPython/DPyGetOpt.py (DPyGetOpt.processArguments): changed to
 	prevent crashes if sys lacks an argv attribute (it happens with
 	embedded interpreters which build a bare-bones sys module).
 	Thanks to a report/bugfix by Adam Hupp <hupp-AT-cs.wisc.edu>.
 
 2003-09-24  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): blanket except around getattr()
 	to protect against poorly written user objects where __getattr__
 	raises exceptions other than AttributeError.  Thanks to a bug
 	report by Oliver Sander <osander-AT-gmx.de>.
 
 	* IPython/FakeModule.py (FakeModule.__repr__): this method was
 	missing.  Thanks to bug report by Ralf Schmitt <ralf-AT-brainbot.com>.
 
 2003-09-09  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): fix bug where
 	unpacking a list whith a callable as first element would
 	mistakenly trigger autocalling.  Thanks to a bug report by Jeffery
 	Collins.
 
 2003-08-25  *** Released version 0.5.0
 
 2003-08-22  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.linereader): Improved handling of
 	improperly defined user exceptions.  Thanks to feedback from Mark
 	Russell <mrussell-AT-verio.net>.
 	
 2003-08-20  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (Inspector.pinfo): changed String Form
 	printing so that it would print multi-line string forms starting
 	with a new line.  This way the formatting is better respected for
 	objects which work hard to make nice string forms.
 
 	* IPython/iplib.py (InteractiveShell.handle_auto): Fix bug where
 	autocall would overtake data access for objects with both
 	__getitem__ and __call__.
 
 2003-08-19  *** Released version 0.5.0-rc1
 
 2003-08-19  Fernando Perez  <[e-mail]>
 
 	* IPython/deep_reload.py (load_tail): single tiny change here
 	seems to fix the long-standing bug of dreload() failing to work
 	for dotted names.  But this module is pretty tricky, so I may have
 	missed some subtlety.  Needs more testing!.
 
 	* IPython/ultraTB.py (VerboseTB.linereader): harden against user
 	exceptions which have badly implemented __str__ methods.
 	(VerboseTB.text): harden against inspect.getinnerframes crashing,
 	which I've been getting reports about from Python 2.3 users.  I
 	wish I had a simple test case to reproduce the problem, so I could
 	either write a cleaner workaround or file a bug report if
 	necessary.
 
 	* IPython/Magic.py (Magic.magic_edit): fixed bug where after
 	making a class 'foo', file 'foo.py' couldn't be edited.  Thanks to
 	a bug report by Tjabo Kloppenburg.
 
 	* IPython/ultraTB.py (VerboseTB.debugger): hardened against pdb
 	crashes.  Wrapped the pdb call in a blanket try/except, since pdb
 	seems rather unstable.  Thanks to a bug report by Tjabo
 	Kloppenburg <tjabo.kloppenburg-AT-unix-ag.uni-siegen.de>.
 
 	* IPython/Release.py (version): release 0.5.0-rc1.  I want to put
 	this out soon because of the critical fixes in the inner loop for
 	generators.
 
 	* IPython/Magic.py (Magic.getargspec): removed.  This (and
 	_get_def) have been obsoleted by OInspect for a long time, I
 	hadn't noticed that they were dead code.
 	(Magic._ofind): restored _ofind functionality for a few literals
 	(those in ["''",'""','[]','{}','()']).  But it won't work anymore
 	for things like "hello".capitalize?, since that would require a
 	potentially dangerous eval() again.
 
 	* IPython/iplib.py (InteractiveShell._prefilter): reorganized the
 	logic a bit more to clean up the escapes handling and minimize the
 	use of _ofind to only necessary cases.  The interactive 'feel' of
 	IPython should have improved quite a bit with the changes in
 	_prefilter and _ofind (besides being far safer than before).
 
 	* IPython/Magic.py (Magic.magic_edit): Fixed old bug (but rather
 	obscure, never reported).  Edit would fail to find the object to
 	edit under some circumstances.
 	(Magic._ofind): CRITICAL FIX.  Finally removed the eval() calls
 	which were causing double-calling of generators.  Those eval calls
 	were _very_ dangerous, since code with side effects could be
 	triggered.  As they say, 'eval is evil'...  These were the
 	nastiest evals in IPython.  Besides, _ofind is now far simpler,
 	and it should also be quite a bit faster.  Its use of inspect is
 	also safer, so perhaps some of the inspect-related crashes I've
 	seen lately with Python 2.3 might be taken care of.  That will
 	need more testing.
 
 2003-08-17  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): significant
 	simplifications to the logic for handling user escapes.  Faster
 	and simpler code.
 
 2003-08-14  Fernando Perez  <[e-mail]>
 
         * IPython/numutils.py (sum_flat): rewrote to be non-recursive.
         Now it requires O(N) storage (N=size(a)) for non-contiguous input,
         but it should be quite a bit faster.  And the recursive version
         generated O(log N) intermediate storage for all rank>1 arrays,
         even if they were contiguous.
         (l1norm): Added this function.
         (norm):  Added this function for arbitrary norms (including
         l-infinity).  l1 and l2 are still special cases for convenience
         and speed.
 	
 2003-08-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_edit): Removed all remaining string
 	exceptions, which now raise PendingDeprecationWarnings in Python
 	2.3.  There were some in Magic and some in Gnuplot2.
 
 2003-06-30  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): modified to call curses only for
 	terminals where TERM=='xterm'.  After problems under many other
 	terminals were reported by Keith Beattie <KSBeattie-AT-lbl.gov>.
 
 	* IPython/iplib.py (complete): removed spurious 'print "IE"' which
 	would be triggered when readline was absent.  This was just an old
 	debugging statement I'd forgotten to take out.
 
 2003-06-20  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (clock): modified to return only user time
 	(not counting system time), after a discussion on scipy.  While
 	system time may be a useful quantity occasionally, it may much
 	more easily be skewed by occasional swapping or other similar
 	activity.
 
 2003-06-05  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (identity): new function, for building
 	arbitrary rank Kronecker deltas (mostly backwards compatible with
 	Numeric.identity)
 
 2003-06-03  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_magic): protect
 	arguments passed to magics with spaces, to allow trailing '\' to
 	work normally (mainly for Windows users).
 
 2003-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Load site._Helper() as help
 	instead of pydoc.help.  This fixes a bizarre behavior where
 	printing '%s' % locals() would trigger the help system.  Now
 	ipython behaves like normal python does.  
 
 	Note that if one does 'from pydoc import help', the bizarre
 	behavior returns, but this will also happen in normal python, so
 	it's not an ipython bug anymore (it has to do with how pydoc.help
 	is implemented).
 
 2003-05-22  Fernando Perez  <[e-mail]>
 
 	* IPython/FlexCompleter.py (Completer.attr_matches): fixed to
 	return [] instead of None when nothing matches, also match to end
 	of line.  Patch by Gary Bishop.
 
 	* IPython/ipmaker.py (make_IPython): Added same sys.excepthook
 	protection as before, for files passed on the command line.  This
 	prevents the CrashHandler from kicking in if user files call into
 	sys.excepthook (such as PyQt and WxWindows have a nasty habit of
 	doing).  After a report by Kasper Souren <Kasper.Souren-AT-ircam.fr>
 
 2003-05-20  *** Released version 0.4.0
 
 2003-05-20  Fernando Perez  <[e-mail]>
 
 	* setup.py: added support for manpages.  It's a bit hackish b/c of
 	a bug in the way the bdist_rpm distutils target handles gzipped
 	manpages, but it works.  After a patch by Jack.
 
 2003-05-19  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py: added a mockup of the kinds module, since
 	it was recently removed from Numeric.  This way, numutils will
 	work for all users even if they are missing kinds.
 
 	* IPython/Magic.py (Magic._ofind): Harden against an inspect
 	failure, which can occur with SWIG-wrapped extensions.  After a
 	crash report from Prabhu.
 
 2003-05-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.excepthook): New method to
 	protect ipython from user code which may call directly
 	sys.excepthook (this looks like an ipython crash to the user, even
 	when it isn't).  After a patch by Gary Bishop <gb-AT-cs.unc.edu>.
 	This is especially important to help users of WxWindows, but may
 	also be useful in other cases.
 
 	* IPython/ultraTB.py (AutoFormattedTB.__call__): Changed to allow
 	an optional tb_offset to be specified, and to preserve exception
 	info if given.  After a patch by Gary Bishop <gb-AT-cs.unc.edu>.
 
 	* ipython.1 (Default): Thanks to Jack's work, we now have manpages!
 
 2003-05-15  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.user_setup): Fix crash when
 	installing for a new user under Windows.
 
 2003-05-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_emacs): New line
 	handler for Emacs comint-based lines.  Currently it doesn't do
 	much (but importantly, it doesn't update the history cache).  In
 	the future it may be expanded if Alex needs more functionality
 	there.
 
 	* IPython/CrashHandler.py (CrashHandler.__call__): Added platform
 	info to crash reports.
 
 	* IPython/iplib.py (InteractiveShell.mainloop): Added -c option,
 	just like Python's -c.  Also fixed crash with invalid -color
 	option value at startup. Thanks to Will French
 	<wfrench-AT-bestweb.net> for the bug report.
 
 2003-05-09  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (EvalDict.__getitem__): Renamed EvalString
 	to EvalDict (it's a mapping, after all) and simplified its code
 	quite a bit, after a nice discussion on c.l.py where Gustavo
 	Córdova <gcordova-AT-sismex.com> suggested the new version.
 
 2003-04-30  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timings_out): modified it to reduce its
 	overhead in the common reps==1 case.
 
 2003-04-29  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timings_out): Modified to use the resource
 	module, which avoids the wraparound problems of time.clock().
 
 2003-04-17  *** Released version 0.2.15pre4
 
 2003-04-17  Fernando Perez  <[e-mail]>
 
 	* setup.py (scriptfiles): Split windows-specific stuff over to a
 	separate file, in an attempt to have a Windows GUI installer.
 	That didn't work, but part of the groundwork is done.
 
 	* IPython/UserConfig/ipythonrc: Added M-i, M-o and M-I for
 	indent/unindent with 4 spaces.  Particularly useful in combination
 	with the new auto-indent option.
 
 2003-04-16  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py: various replacements of self.rc for
 	self.shell.rc.  A lot more remains to be done to fully disentangle
 	this class from the main Shell class.
 
 	* IPython/GnuplotRuntime.py: added checks for mouse support so
 	that we don't try to enable it if the current gnuplot doesn't
 	really support it.  Also added checks so that we don't try to
 	enable persist under Windows (where Gnuplot doesn't recognize the
 	option).
 
 	* IPython/iplib.py (InteractiveShell.interact): Added optional
 	auto-indenting code, after a patch by King C. Shu
 	<kingshu-AT-myrealbox.com>. It's off by default because it doesn't
 	get along well with pasting indented code.  If I ever figure out
 	how to make that part go well, it will become on by default.
 
 	* IPython/Prompts.py (Prompt1.auto_rewrite): Fixed bug which would
 	crash ipython if there was an unmatched '%' in the user's prompt
 	string.  Reported by Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
 	
 	* IPython/iplib.py (InteractiveShell.interact): removed the
 	ability to ask the user whether he wants to crash or not at the
 	'last line' exception handler.  Calling functions at that point
 	changes the stack, and the error reports would have incorrect
 	tracebacks.
 
 	* IPython/Magic.py (Magic.magic_page): Added new @page magic, to
 	pass through a peger a pretty-printed form of any object.  After a
 	contribution by Olivier Aubert <oaubert-AT-bat710.univ-lyon1.fr>
 
 2003-04-14  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.user_setup): Fixed bug where
 	all files in ~ would be modified at first install (instead of
 	~/.ipython).  This could be potentially disastrous, as the
 	modification (make line-endings native) could damage binary files.
 	
 2003-04-10  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_help): Modified to
 	handle only lines which are invalid python.  This now means that
 	lines like 'x=1 #?' execute properly.  Thanks to Jeffery Collins
 	for the bug report.
 
 2003-04-01  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.showtraceback): Fixed bug
 	where failing to set sys.last_traceback would crash pdb.pm().
 	Thanks to Jeffery D. Collins <Jeff.Collins-AT-vexcel.com> for the bug
 	report.
 
 2003-03-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): rstrip() output of profiler
 	before printing it (it had a lot of spurious blank lines at the
 	end).
 
 	* IPython/Gnuplot2.py (Gnuplot.hardcopy): fixed bug where lpr
 	output would be sent 21 times!  Obviously people don't use this
 	too often, or I would have heard about it.
 
 2003-03-24  Fernando Perez  <[e-mail]>
 
 	* setup.py (scriptfiles): renamed the data_files parameter from
 	'base' to 'data' to fix rpm build issues.  Thanks to Ralf Ahlbrink
 	for the patch.
 
 2003-03-20  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (error): added error() and fatal()
 	functions.
 
 2003-03-18  *** Released version 0.2.15pre3
 
 2003-03-18  Fernando Perez  <[e-mail]>
 
 	* setupext/install_data_ext.py
 	(install_data_ext.initialize_options): Class contributed by Jack
 	Moffit for fixing the old distutils hack.  He is sending this to
 	the distutils folks so in the future we may not need it as a
 	private fix.
 
 	* MANIFEST.in: Extensive reorganization, based on Jack Moffit's
 	changes for Debian packaging.  See his patch for full details.
 	The old distutils hack of making the ipythonrc* files carry a
 	bogus .py extension is gone, at last.  Examples were moved to a
 	separate subdir under doc/, and the separate executable scripts
 	now live in their own directory.  Overall a great cleanup.  The
 	manual was updated to use the new files, and setup.py has been
 	fixed for this setup.
 
 	* IPython/PyColorize.py (Parser.usage): made non-executable and
 	created a pycolor wrapper around it to be included as a script.
 
 2003-03-12  *** Released version 0.2.15pre2
 
 2003-03-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ColorANSI.py (make_color_table): Finally fixed the
 	long-standing problem with garbage characters in some terminals.
 	The issue was really that the \001 and \002 escapes must _only_ be
 	passed to input prompts (which call readline), but _never_ to
 	normal text to be printed on screen.  I changed ColorANSI to have
 	two classes: TermColors and InputTermColors, each with the
 	appropriate escapes for input prompts or normal text.  The code in
 	Prompts.py got slightly more complicated, but this very old and
 	annoying bug is finally fixed.  
 
 	All the credit for nailing down the real origin of this problem
 	and the correct solution goes to Jack Moffit <jack-AT-xiph.org>.
 	*Many* thanks to him for spending quite a bit of effort on this.
 
 2003-03-05  *** Released version 0.2.15pre1
 
 2003-03-03  Fernando Perez  <[e-mail]>
 
 	* IPython/FakeModule.py: Moved the former _FakeModule to a
 	separate file, because it's also needed by Magic (to fix a similar
 	pickle-related issue in @run).
 
 2003-03-02  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_autocall): new magic to control
 	the autocall option at runtime.
 	(Magic.magic_dhist): changed self.user_ns to self.shell.user_ns
 	across Magic.py to start separating Magic from InteractiveShell.
 	(Magic._ofind): Fixed to return proper namespace for dotted
 	names. Before, a dotted name would always return 'not currently
 	defined', because it would find the 'parent'. s.x would be found,
 	but since 'x' isn't defined by itself, it would get confused.
 	(Magic.magic_run): Fixed pickling problems reported by Ralf
 	Ahlbrink <RAhlbrink-AT-RosenInspection.net>.  The fix was similar to
 	that I'd used when Mike Heeter reported similar issues at the
 	top-level, but now for @run.  It boils down to injecting the
 	namespace where code is being executed with something that looks
 	enough like a module to fool pickle.dump().  Since a pickle stores
 	a named reference to the importing module, we need this for
 	pickles to save something sensible.
 
 	* IPython/ipmaker.py (make_IPython): added an autocall option.
 
 	* IPython/iplib.py (InteractiveShell._prefilter): reordered all of
 	the auto-eval code.  Now autocalling is an option, and the code is
 	also vastly safer.  There is no more eval() involved at all.
 
 2003-03-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): Changed interface to return a
 	dict with named keys instead of a tuple.
 
 	* IPython: Started using CVS for IPython as of 0.2.15pre1.
 
 	* setup.py (make_shortcut): Fixed message about directories
 	created during Windows installation (the directories were ok, just
 	the printed message was misleading).  Thanks to Chris Liechti
 	<cliechti-AT-gmx.net> for the heads up.
 
 2003-02-21  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Fixed catching
 	of ValueError exception when checking for auto-execution.  This
 	one is raised by things like Numeric arrays arr.flat when the
 	array is non-contiguous.
 
 2003-01-31  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (SystemExec.bq): Fixed bug where bq would
 	not return any value at all (even though the command would get
 	executed).
 	(xsys): Flush stdout right after printing the command to ensure
 	proper ordering of commands and command output in the total
 	output.
 	(SystemExec/xsys/bq): Switched the names of xsys/bq and
 	system/getoutput as defaults.  The old ones are kept for
 	compatibility reasons, so no code which uses this library needs
 	changing.
 
 2003-01-27  *** Released version 0.2.14
 
 2003-01-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_edit): Fixed problem where
 	functions defined in previous edit sessions could not be re-edited
 	(because the temp files were immediately removed).  Now temp files
 	are removed only at IPython's exit.
 	(Magic.magic_run): Improved @run to perform shell-like expansions
 	on its arguments (~users and $VARS).  With this, @run becomes more
 	like a normal command-line.
 
 	* IPython/Shell.py (IPShellEmbed.__call__): Fixed a bunch of small
 	bugs related to embedding and cleaned up that code.  A fairly
 	important one was the impossibility to access the global namespace
 	through the embedded IPython (only local variables were visible).
 
 2003-01-14  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Fixed
 	auto-calling to be a bit more conservative.  Now it doesn't get
 	triggered if any of '!=()<>' are in the rest of the input line, to
 	allow comparing callables.  Thanks to Alex for the heads up.
 
 2003-01-07  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): fixed estimation of the number of
 	lines in a string to be paged to simply count newlines. This
 	prevents over-guessing due to embedded escape sequences. A better
 	long-term solution would involve stripping out the control chars
 	for the count, but it's potentially so expensive I just don't
 	think it's worth doing.
 
 2002-12-19  *** Released version 0.2.14pre50
 
 2002-12-19  Fernando Perez  <[e-mail]>
 
 	* tools/release (version): Changed release scripts to inform
 	Andrea and build a NEWS file with a list of recent changes.
 
 	* IPython/ColorANSI.py (__all__): changed terminal detection
 	code. Seems to work better for xterms without breaking
 	konsole. Will need more testing to determine if WinXP and Mac OSX
 	also work ok.
 
 2002-12-18  *** Released version 0.2.14pre49
 
 2002-12-18  Fernando Perez  <[e-mail]>
 
 	* Docs: added new info about Mac OSX, from Andrea.
 
 	* IPython/Gnuplot2.py (String): Added a String PlotItem class to
 	allow direct plotting of python strings whose format is the same
 	of gnuplot data files.
 
 2002-12-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): fixed default (y)
 	value of exit question to be acknowledged.
 
 2002-12-03  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py: removed generators, which had been added
 	by mistake in an earlier debugging run. This was causing trouble
 	to users of python 2.1.x. Thanks to Abel Daniel <abli-AT-freemail.hu>
 	for pointing this out.
 
 2002-11-17  Fernando Perez  <[e-mail]>
 
 	* Manual: updated the Gnuplot section.
 
 	* IPython/GnuplotRuntime.py: refactored a lot all this code, with
 	a much better split of what goes in Runtime and what goes in
 	Interactive.
 
 	* IPython/ipmaker.py: fixed bug where import_fail_info wasn't
 	being imported from iplib.
 
 	* IPython/GnuplotInteractive.py (magic_gpc): renamed @gp to @gpc
 	for command-passing. Now the global Gnuplot instance is called
 	'gp' instead of 'g', which was really a far too fragile and
 	common name.
 
 	* IPython/Gnuplot2.py (eps_fix_bbox): added this to fix broken
 	bounding boxes generated by Gnuplot for square plots.
 
 	* IPython/genutils.py (popkey): new function added. I should
 	suggest this on c.l.py as a dict method, it seems useful.
 
 	* IPython/Gnuplot2.py (Gnuplot.plot): Overhauled plot and replot
 	to transparently handle PostScript generation. MUCH better than
 	the previous plot_eps/replot_eps (which I removed now). The code
 	is also fairly clean and well documented now (including
 	docstrings).
 
 2002-11-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_edit): fixed docstring
 	(inconsistent with options).
 
 	* IPython/Gnuplot2.py (Gnuplot.hardcopy): hardcopy had been
 	manually disabled, I don't know why. Fixed it.
 	(Gnuplot._plot_eps): added new plot_eps/replot_eps to get directly
 	eps output.
 
 2002-11-12  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (ask_yes_no): trap EOF and ^C so that they
 	don't propagate up to caller. Fixes crash reported by François
 	Pinard.
 
 2002-11-09  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): fixed problem with writing
 	history file for new users.
 	(make_IPython): fixed bug where initial install would leave the
 	user running in the .ipython dir.
 	(make_IPython): fixed bug where config dir .ipython would be
 	created regardless of the given -ipythondir option. Thanks to Cory
 	Dodt <cdodt-AT-fcoe.k12.ca.us> for the bug report.
 
 	* IPython/genutils.py (ask_yes_no): new function for asking yes/no
 	type confirmations. Will need to use it in all of IPython's code
 	consistently.
 	
 	* IPython/CrashHandler.py (CrashHandler.__call__): changed the
 	context to print 31 lines instead of the default 5. This will make
 	the crash reports extremely detailed in case the problem is in
 	libraries I don't have access to.
 
 	* IPython/iplib.py (InteractiveShell.interact): changed the 'last
 	line of defense' code to still crash, but giving users fair
 	warning. I don't want internal errors to go unreported: if there's
 	an internal problem, IPython should crash and generate a full
 	report.
 
 2002-11-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): added code to trap
 	otherwise uncaught exceptions which can appear if people set
 	sys.stdout to something badly broken. Thanks to a crash report
 	from henni-AT-mail.brainbot.com.
 
 2002-11-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): added
 	__IPYTHON__active to the builtins. It's a flag which goes on when
 	the interaction starts and goes off again when it stops. This
 	allows embedding code to detect being inside IPython. Before this
 	was done via __IPYTHON__, but that only shows that an IPython
 	instance has been created.
 
 	* IPython/Magic.py (Magic.magic_env): I realized that in a
 	UserDict, instance.data holds the data as a normal dict. So I
 	modified @env to return os.environ.data instead of rebuilding a
 	dict by hand.
 
 2002-11-02  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (warn): changed so that level 1 prints no
 	header. Level 2 is now the default (with 'WARNING' header, as
 	before). I think I tracked all places where changes were needed in
 	IPython, but outside code using the old level numbering may have
 	broken.
 
 	* IPython/iplib.py (InteractiveShell.runcode): added this to
 	handle the tracebacks in SystemExit traps correctly. The previous
 	code (through interact) was printing more of the stack than
 	necessary, showing IPython internal code to the user.
 
 	* IPython/UserConfig/ipythonrc.py: Made confirm_exit 1 by
 	default. Now that the default at the confirmation prompt is yes,
 	it's not so intrusive. François' argument that ipython sessions
 	tend to be complex enough not to lose them from an accidental C-d,
 	is a valid one.
 
 	* IPython/iplib.py (InteractiveShell.interact): added a
 	showtraceback() call to the SystemExit trap, and modified the exit
 	confirmation to have yes as the default.
 
 	* IPython/UserConfig/ipythonrc.py: removed 'session' option from
 	this file. It's been gone from the code for a long time, this was
 	simply leftover junk.
 
 2002-11-01  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/ipythonrc.py: new confirm_exit option
 	added. If set, IPython now traps EOF and asks for
 	confirmation. After a request by François Pinard.
 
 	* IPython/Magic.py (Magic.magic_Exit): New @Exit and @Quit instead
 	of @abort, and with a new (better) mechanism for handling the
 	exceptions.
 
 2002-10-27  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): updated the --help information and
 	the ipythonrc file to indicate that -log generates
 	./ipython.log. Also fixed the corresponding info in @logstart.
 	This and several other fixes in the manuals thanks to reports by
 	François Pinard <pinard-AT-iro.umontreal.ca>.
 	
 	* IPython/Logger.py (Logger.switch_log): Fixed error message to
 	refer to @logstart (instead of @log, which doesn't exist).
 
 	* IPython/iplib.py (InteractiveShell._prefilter): fixed
 	AttributeError crash. Thanks to Christopher Armstrong
 	<radix-AT-twistedmatrix.com> for the report/fix. This bug had been
 	introduced recently (in 0.2.14pre37) with the fix to the eval
 	problem mentioned below.
 	
 2002-10-17  Fernando Perez  <[e-mail]>
 
 	* IPython/ConfigLoader.py (ConfigLoader.load): Fixes for Windows
 	installation. Thanks to Leonardo Santagada <retype-AT-terra.com.br>.
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Many changes to
 	this function to fix a problem reported by Alex Schmolck. He saw
 	it with list comprehensions and generators, which were getting
 	called twice. The real problem was an 'eval' call in testing for
 	automagic which was evaluating the input line silently. 
 
 	This is a potentially very nasty bug, if the input has side
 	effects which must not be repeated. The code is much cleaner now,
 	without any blanket 'except' left and with a regexp test for
 	actual function names. 
 
 	But an eval remains, which I'm not fully comfortable with. I just
 	don't know how to find out if an expression could be a callable in
 	the user's namespace without doing an eval on the string. However
 	that string is now much more strictly checked so that no code
 	slips by, so the eval should only happen for things that can
 	really be only function/method names.
 
 2002-10-15  Fernando Perez  <[e-mail]>
 
 	* Updated LyX to 1.2.1 so I can work on the docs again. Added Mac
 	OSX information to main manual, removed README_Mac_OSX file from
 	distribution. Also updated credits for recent additions.
 
 2002-10-10  Fernando Perez  <[e-mail]>
 
 	* README_Mac_OSX: Added a README for Mac OSX users for fixing
 	terminal-related issues. Many thanks to Andrea Riciputi
 	<andrea.riciputi-AT-libero.it> for writing it.
 
 	* IPython/UserConfig/ipythonrc.py: Fixes to various small issues,
 	thanks to Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
 
 	* setup.py (make_shortcut): Fixes for Windows installation. Thanks
 	to Fredrik Kant <fredrik.kant-AT-front.com> and Syver Enstad
 	<syver-en-AT-online.no> who both submitted patches for this problem.
 
 	* IPython/iplib.py (InteractiveShell.embed_mainloop): Patch for
 	global embedding to make sure that things don't overwrite user
 	globals accidentally. Thanks to Richard <rxe-AT-renre-europe.com>
 
 	* IPython/Gnuplot2.py (gp): Patch for Gnuplot.py 1.6
 	compatibility. Thanks to Hayden Callow
 	<h.callow-AT-elec.canterbury.ac.nz>
 
 2002-10-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (PlotItem): Added 'index' option for
 	Gnuplot.File objects.
 	      
 2002-07-23  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timing): Added timings() and timing() for
 	quick access to the most commonly needed data, the execution
 	times. Old timing() renamed to timings_out().
 
 2002-07-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellEmbed.restore_system_completer): fixed
 	bug with nested instances disrupting the parent's tab completion.
 
 	* IPython/iplib.py (all_completions): Added Alex Schmolck's
 	all_completions code to begin the emacs integration.
 
 	* IPython/Gnuplot2.py (zip_items): Added optional 'titles'
 	argument to allow titling individual arrays when plotting.
 
 2002-07-15  Fernando Perez  <[e-mail]>
 
 	* setup.py (make_shortcut): changed to retrieve the value of
 	'Program Files' directory from the registry (this value changes in
 	non-english versions of Windows). Thanks to Thomas Fanslau
 	<tfanslau-AT-gmx.de> for the report.
 
 2002-07-10  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.debugger): enabled workaround for
 	a bug in pdb, which crashes if a line with only whitespace is
 	entered. Bug report submitted to sourceforge.
 
 2002-07-09  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.nullrepr): fixed rare crash when
 	reporting exceptions (it's a bug in inspect.py, I just set a
 	workaround).
 
 2002-07-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): fixed reference to
 	__IPYTHON__ in __builtins__ to show up in user_ns.
 
 2002-07-03  Fernando Perez  <[e-mail]>
 
 	* IPython/GnuplotInteractive.py (magic_gp_set_default): changed
 	name from @gp_set_instance to @gp_set_default.
 
 	* IPython/ipmaker.py (make_IPython): default editor value set to
 	'0' (a string), to match the rc file. Otherwise will crash when
 	.strip() is called on it.
 	
 
 2002-06-28  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): fix importing
 	of files in current directory when a file is executed via
 	@run. Patch also by RA <ralf_ahlbrink-AT-web.de>.
 
 	* setup.py (manfiles): fix for rpm builds, submitted by RA
 	<ralf_ahlbrink-AT-web.de>. Now we have RPMs!
 
 	* IPython/ipmaker.py (make_IPython): fixed lookup of default
 	editor when set to '0'. Problem was, '0' evaluates to True (it's a
 	string!). A. Schmolck caught this one.
 
 2002-06-27  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): fixed bug when running user
 	defined files at the cmd line. __name__ wasn't being set to
 	__main__.
 
 	* IPython/Gnuplot2.py (zip_items): improved it so it can plot also
 	regular lists and tuples besides Numeric arrays.
 
 	* IPython/Prompts.py (CachedOutput.__call__): Added output
 	supression for input ending with ';'. Similar to Mathematica and
 	Matlab. The _* vars and Out[] list are still updated, just like
 	Mathematica behaves.
 
 2002-06-25  Fernando Perez  <[e-mail]>
 
 	* IPython/ConfigLoader.py (ConfigLoader.load): fixed checking of
 	.ini extensions for profiels under Windows.
 
 	* IPython/OInspect.py (Inspector.pinfo): improved alignment of
 	string form. Fix contributed by Alexander Schmolck
 	<a.schmolck-AT-gmx.net>
 
 	* IPython/GnuplotRuntime.py (gp_new): new function. Returns a
 	pre-configured Gnuplot instance.
 
 2002-06-21  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (exp_safe): new function, works around the
 	underflow problems in Numeric.
 	(log2): New fn. Safe log in base 2: returns exact integer answer
 	for exact integer powers of 2.
 
 	* IPython/Magic.py (get_py_filename): fixed it not expanding '~'
 	properly.
 
 2002-06-20  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timing): new function like
 	Mathematica's. Similar to time_test, but returns more info.
 
 2002-06-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_save): modified @save and @r
 	according to Mike Heeter's suggestions.
 
 2002-06-16  Fernando Perez  <[e-mail]>
 
 	* IPython/GnuplotRuntime.py: Massive overhaul to the Gnuplot
 	system. GnuplotMagic is gone as a user-directory option. New files
 	make it easier to use all the gnuplot stuff both from external
 	programs as well as from IPython. Had to rewrite part of
 	hardcopy() b/c of a strange bug: often the ps files simply don't
 	get created, and require a repeat of the command (often several
 	times).
 
 	* IPython/ultraTB.py (AutoFormattedTB.__call__): changed to
 	resolve output channel at call time, so that if sys.stderr has
 	been redirected by user this gets honored.
 
 2002-06-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShell.__init__): Changed IPythonShell to
 	IPShell. Kept a copy with the old names to avoid breaking people's
 	embedded code.
 
 	* IPython/ipython: simplified it to the bare minimum after
 	Holger's suggestions. Added info about how to use it in
 	PYTHONSTARTUP.
 
 	* IPython/Shell.py (IPythonShell): changed the options passing
 	from a string with funky %s replacements to a straight list. Maybe
 	a bit more typing, but it follows sys.argv conventions, so there's
 	less special-casing to remember.
 
 2002-06-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_r): new magic auto-repeat
 	command. Thanks to a suggestion by Mike Heeter.
 	(Magic.magic_pfile): added behavior to look at filenames if given
 	arg is not a defined object.
 	(Magic.magic_save): New @save function to save code snippets. Also
 	a Mike Heeter idea.
 
 	* IPython/UserConfig/GnuplotMagic.py (plot): Improvements to
 	plot() and replot(). Much more convenient now, especially for
 	interactive use.
 
 	* IPython/Magic.py (Magic.magic_run): Added .py automatically to
 	filenames.
 
 2002-06-02  Fernando Perez  <[e-mail]>
 
 	* IPython/Struct.py (Struct.__init__): modified to admit
 	initialization via another struct.
 
 	* IPython/genutils.py (SystemExec.__init__): New stateful
 	interface to xsys and bq. Useful for writing system scripts.
 
 2002-05-30  Fernando Perez  <[e-mail]>
 
 	* MANIFEST.in: Changed docfile selection to exclude all the lyx
 	documents. This will make the user download smaller (it's getting
 	too big).
 
 2002-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (_FakeModule.__init__): New class introduced to
 	fix problems with shelve and pickle. Seems to work, but I don't
 	know if corner cases break it. Thanks to Mike Heeter
 	<korora-AT-SDF.LONESTAR.ORG> for the bug reports and test cases.
 
 2002-05-24  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Macro.__init__): fixed magics embedded in
 	macros having broken.
 
 2002-05-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_logstart): fixed recently
 	introduced logging bug: all history before logging started was
 	being written one character per line! This came from the redesign
 	of the input history as a special list which slices to strings,
 	not to lists.
 
 2002-05-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (CachedOutput.__init__): made the color table
 	be an attribute of all classes in this module. The design of these
 	classes needs some serious overhauling.
 
 	* IPython/DPyGetOpt.py (DPyGetOpt.setPosixCompliance): fixed bug
 	which was ignoring '_' in option names.
 
 	* IPython/ultraTB.py (FormattedTB.__init__): Changed
 	'Verbose_novars' to 'Context' and made it the new default. It's a
 	bit more readable and also safer than verbose.
 
 	* IPython/PyColorize.py (Parser.__call__): Fixed coloring of
 	triple-quoted strings.
 
 	* IPython/OInspect.py (__all__): new module exposing the object
 	introspection facilities. Now the corresponding magics are dummy
 	wrappers around this. Having this module will make it much easier
 	to put these functions into our modified pdb.
 	This new object inspector system uses the new colorizing module,
 	so source code and other things are nicely syntax highlighted.
 
 2002-05-18  Fernando Perez  <[e-mail]>
 
 	* IPython/ColorANSI.py: Split the coloring tools into a separate
 	module so I can use them in other code easier (they were part of
 	ultraTB).
 
 2002-05-17  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/GnuplotMagic.py (magic_gp_set_instance):
 	fixed it to set the global 'g' also to the called instance, as
 	long as 'g' was still a gnuplot instance (so it doesn't overwrite
 	user's 'g' variables).
 
 	* IPython/iplib.py (InteractiveShell.__init__): Added In/Out
 	global variables (aliases to _ih,_oh) so that users which expect
 	In[5] or Out[7] to work aren't unpleasantly surprised.
 	(InputList.__getslice__): new class to allow executing slices of
 	input history directly. Very simple class, complements the use of
 	macros.
 
 2002-05-16  Fernando Perez  <[e-mail]>
 
 	* setup.py (docdirbase): make doc directory be just doc/IPython
 	without version numbers, it will reduce clutter for users.
 
 	* IPython/Magic.py (Magic.magic_run): Add explicit local dict to
 	execfile call to prevent possible memory leak. See for details:
 	http://mail.python.org/pipermail/python-list/2002-February/088476.html
 
 2002-05-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_psource): made the object
 	introspection names be more standard: pdoc, pdef, pfile and
 	psource. They all print/page their output, and it makes
 	remembering them easier. Kept old names for compatibility as
 	aliases.
 
 2002-05-14  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/GnuplotMagic.py: I think I finally understood
 	what the mouse problem was. The trick is to use gnuplot with temp
 	files and NOT with pipes (for data communication), because having
 	both pipes and the mouse on is bad news.
 
 2002-05-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): fixed namespace order search
 	bug. Information would be reported about builtins even when
 	user-defined functions overrode them.
 
 2002-05-11  Fernando Perez  <[e-mail]>
 
 	* IPython/__init__.py (__all__): removed FlexCompleter from
 	__all__ so that things don't fail in platforms without readline.
 
 2002-05-10  Fernando Perez  <[e-mail]>
 
 	* IPython/__init__.py (__all__): removed numutils from __all__ b/c
 	it requires Numeric, effectively making Numeric a dependency for
 	IPython.
 
 	* Released 0.2.13
 
 	* IPython/Magic.py (Magic.magic_prun): big overhaul to the
 	profiler interface. Now all the major options from the profiler
 	module are directly supported in IPython, both for single
 	expressions (@prun) and for full programs (@run -p).
 
 2002-05-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_doc): fixed to show docstrings of
 	magic properly formatted for screen.
 
 	* setup.py (make_shortcut): Changed things to put pdf version in
 	doc/ instead of doc/manual (had to change lyxport a bit).
 
 	* IPython/Magic.py (Profile.string_stats): made profile runs go
 	through pager (they are long and a pager allows searching, saving,
 	etc.)
 
 2002-05-08  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.12
 
 2002-05-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_hist): small bug fixed (recently
 	introduced); 'hist n1 n2' was broken.
 	(Magic.magic_pdb): added optional on/off arguments to @pdb
 	(Magic.magic_run): added option -i to @run, which executes code in
 	the IPython namespace instead of a clean one. Also added @irun as
 	an alias to @run -i.
 
 	* IPython/UserConfig/GnuplotMagic.py (magic_gp_set_instance):
 	fixed (it didn't really do anything, the namespaces were wrong).
 
 	* IPython/Debugger.py (__init__): Added workaround for python 2.1
 
 	* IPython/__init__.py (__all__): Fixed package namespace, now
 	'import IPython' does give access to IPython.<all> as
 	expected. Also renamed __release__ to Release.
 
 	* IPython/Debugger.py (__license__): created new Pdb class which
 	functions like a drop-in for the normal pdb.Pdb but does NOT
 	import readline by default. This way it doesn't muck up IPython's
 	readline handling, and now tab-completion finally works in the
 	debugger -- sort of. It completes things globally visible, but the
 	completer doesn't track the stack as pdb walks it. That's a bit
 	tricky, and I'll have to implement it later.
 
 2002-05-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_oinfo): fixed formatting bug for
 	magic docstrings when printed via ? (explicit \'s were being
 	printed).
 
 	* IPython/ipmaker.py (make_IPython): fixed namespace
 	identification bug. Now variables loaded via logs or command-line
 	files are recognized in the interactive namespace by @who.
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): Fixed bug in
 	log replay system stemming from the string form of Structs.
 
 	* IPython/Magic.py (Macro.__init__): improved macros to properly
 	handle magic commands in them.
 	(Magic.magic_logstart): usernames are now expanded so 'logstart
 	~/mylog' now works.
 
 	* IPython/iplib.py (complete): fixed bug where paths starting with
 	'/' would be completed as magic names.
 
 2002-05-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_run): added options -p and -f to
 	allow running full programs under the profiler's control.
 
 	* IPython/ultraTB.py (FormattedTB.__init__): Added Verbose_novars
 	mode to report exceptions verbosely but without formatting
 	variables. This addresses the issue of ipython 'freezing' (it's
 	not frozen, but caught in an expensive formatting loop) when huge
 	variables are in the context of an exception.
 	(VerboseTB.text): Added '--->' markers at line where exception was
 	triggered. Much clearer to read, especially in NoColor modes.
 
 	* IPython/Magic.py (Magic.magic_run): bugfix: -n option had been
 	implemented in reverse when changing to the new parse_options().
 
 2002-05-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.parse_options): new function so that
 	magics can parse options easier.
 	(Magic.magic_prun): new function similar to profile.run(),
 	suggested by Chris Hart.
 	(Magic.magic_cd): fixed behavior so that it only changes if
 	directory actually is in history.
 
 	* IPython/usage.py (__doc__): added information about potential
 	slowness of Verbose exception mode when there are huge data
 	structures to be formatted (thanks to Archie Paulson).
 
 	* IPython/ipmaker.py (make_IPython): Changed default logging
 	(when simply called with -log) to use curr_dir/ipython.log in
 	rotate mode. Fixed crash which was occuring with -log before
 	(thanks to Jim Boyle).
 
 2002-05-01  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.11 for these fixes (mainly the ultraTB one which
 	was nasty -- though somewhat of a corner case).
 
 	* IPython/ultraTB.py (AutoFormattedTB.text): renamed __text to
 	text (was a bug).
 
 2002-04-30  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/GnuplotMagic.py (magic_gp): Minor fix to add
 	a print after ^D or ^C from the user so that the In[] prompt
 	doesn't over-run the gnuplot one.
 
 2002-04-29  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.10
 
 	* IPython/__release__.py (version): get date dynamically.
 
 	* Misc. documentation updates thanks to Arnd's comments. Also ran
 	a full spellcheck on the manual (hadn't been done in a while).
 
 2002-04-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_logstart): Fixed bug where
 	starting a log in mid-session would reset the input history list.
 
 2002-04-26  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.wait): Fixed bug where not
 	all files were being included in an update. Now anything in
 	UserConfig that matches [A-Za-z]*.py will go (this excludes
 	__init__.py)
 
 2002-04-25  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): Added __IPYTHON__
 	to __builtins__ so that any form of embedded or imported code can
 	test for being inside IPython.
 
 	* IPython/UserConfig/GnuplotMagic.py: (magic_gp_set_instance):
 	changed to GnuplotMagic because it's now an importable module,
 	this makes the name follow that of the standard Gnuplot module.
 	GnuplotMagic can now be loaded at any time in mid-session.
 
 2002-04-24  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py: removed SIUnits. It doesn't properly set
 	the globals (IPython has its own namespace) and the
 	PhysicalQuantity stuff is much better anyway.
 
 	* IPython/UserConfig/example-gnuplot.py (g2): Added gnuplot
 	embedding example to standard user directory for
 	distribution. Also put it in the manual.
 
 	* IPython/numutils.py (gnuplot_exec): Changed to take a gnuplot
 	instance as first argument (so it doesn't rely on some obscure
 	hidden global).
 
 	* IPython/UserConfig/ipythonrc.py: put () back in accepted
 	delimiters. While it prevents ().TAB from working, it allows
 	completions in open (... expressions. This is by far a more common
 	case.
 
 2002-04-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/InterpreterPasteInput.py: new
 	syntax-processing module for pasting lines with >>> or ... at the
 	start.
 
 	* IPython/Extensions/PhysicalQ_Interactive.py
 	(PhysicalQuantityInteractive.__int__): fixed to work with either
 	Numeric or math.
 
 	* IPython/UserConfig/ipythonrc-numeric.py: reorganized the
 	provided profiles. Now we have:
 	-math -> math module as * and cmath with its own namespace.
 	-numeric -> Numeric as *, plus gnuplot & grace
 	-physics -> same as before
 
 	* IPython/Magic.py (Magic.magic_magic): Fixed bug where
 	user-defined magics wouldn't be found by @magic if they were
 	defined as class methods. Also cleaned up the namespace search
 	logic and the string building (to use %s instead of many repeated
 	string adds).
 
 	* IPython/UserConfig/example-magic.py (magic_foo): updated example
 	of user-defined magics to operate with class methods (cleaner, in
 	line with the gnuplot code).
 
 2002-04-22  Fernando Perez  <[e-mail]>
 
 	* setup.py: updated dependency list so that manual is updated when
 	all included files change.
 
 	* IPython/ipmaker.py (make_IPython): Fixed bug which was ignoring
 	the delimiter removal option (the fix is ugly right now).
 
 	* IPython/UserConfig/ipythonrc-physics.py: simplified not to load
 	all of the math profile (quicker loading, no conflict between
 	g-9.8 and g-gnuplot).
 
 	* IPython/CrashHandler.py (CrashHandler.__call__): changed default
 	name of post-mortem files to IPython_crash_report.txt.
 
 	* Cleanup/update of the docs. Added all the new readline info and
 	formatted all lists as 'real lists'.
 
 	* IPython/ipmaker.py (make_IPython): removed now-obsolete
 	tab-completion options, since the full readline parse_and_bind is
 	now accessible.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): Changed
 	handling of readline options. Now users can specify any string to
 	be passed to parse_and_bind(), as well as the delimiters to be
 	removed.
 	(InteractiveShell.__init__): Added __name__ to the global
 	namespace so that things like Itpl which rely on its existence
 	don't crash.
 	(InteractiveShell._prefilter): Defined the default with a _ so
 	that prefilter() is easier to override, while the default one
 	remains available.
 
 2002-04-18  Fernando Perez  <[e-mail]>
 
 	* Added information about pdb in the docs.
 
 2002-04-17  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): added rc_override option to
 	allow passing config options at creation time which may override
 	anything set in the config files or command line. This is
 	particularly useful for configuring embedded instances.
 
 2002-04-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): Fixed a nasty bug which could
 	crash embedded instances because of the input cache falling out of
 	sync with the output counter.
 
 	* IPython/Shell.py (IPythonShellEmbed.__init__): added a debug
 	mode which calls pdb after an uncaught exception in IPython itself.
 
 2002-04-14  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.showtraceback): pdb mucks up
 	readline, fix it back after each call.
 
 	* IPython/ultraTB.py (AutoFormattedTB.__text): made text a private
 	method to force all access via __call__(), which guarantees that
 	traceback references are properly deleted.
 
 	* IPython/Prompts.py (CachedOutput._display): minor fixes to
 	improve printing when pprint is in use.
 
 2002-04-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): SystemExit
 	exceptions aren't caught anymore. If the user triggers one, he
 	should know why he's doing it and it should go all the way up,
 	just like any other exception. So now @abort will fully kill the
 	embedded interpreter and the embedding code (unless that happens
 	to catch SystemExit).
 
 	* IPython/ultraTB.py (VerboseTB.__init__): added a call_pdb flag
 	and a debugger() method to invoke the interactive pdb debugger
 	after printing exception information. Also added the corresponding
 	-pdb option and @pdb magic to control this feature, and updated
 	the docs. After a suggestion from Christopher Hart
 	(hart-AT-caltech.edu).
 
 2002-04-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__init__): modified to use
 	the exception handlers defined by the user (not the CrashHandler)
 	so that user exceptions don't trigger an ipython bug report.
 
 	* IPython/ultraTB.py (ColorTB.__init__): made the color scheme
 	configurable (it should have always been so).
 
 2002-03-26  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): many changes here
 	and there to fix embedding namespace issues. This should all be
 	done in a more elegant way.
 
 2002-03-25  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (get_home_dir): Try to make it work under
 	win9x also.
 
 2002-03-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__init__): leave
 	sys.displayhook untouched upon __init__.
 
 2002-03-19  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.9 (for embedding bug, basically).
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): Trap SystemExit
 	exceptions so that enclosing shell's state can be restored.
 
 	* Changed magic_gnuplot.py to magic-gnuplot.py to standardize
 	naming conventions in the .ipython/ dir.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): removed '-'
 	from delimiters list so filenames with - in them get expanded.
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): fixed bug with
 	sys.displayhook not being properly restored after an embedded call.
 
  2002-03-18  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.8
 
 	* IPython/iplib.py (InteractiveShell.user_setup): fixed bug where
 	some files weren't being included in a -upgrade.
 	(InteractiveShell.init_readline): Added 'set show-all-if-ambiguous
 	on' so that the first tab completes.
 	(InteractiveShell.handle_magic): fixed bug with spaces around
 	quotes breaking many magic commands.
 
 	* setup.py: added note about ignoring the syntax error messages at
 	installation.
 
 	* IPython/UserConfig/magic_gnuplot.py (magic_gp): finished
 	streamlining the gnuplot interface, now there's only one magic @gp.
 
 2002-03-17  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/magic_gnuplot.py: new name for the
 	example-magic_pm.py file. Much enhanced system, now with a shell
 	for communicating directly with gnuplot, one command at a time.
 
 	* IPython/Magic.py (Magic.magic_run): added option -n to prevent
 	setting __name__=='__main__'.
 
 	* IPython/UserConfig/example-magic_pm.py (magic_pm): Added
 	mini-shell for accessing gnuplot from inside ipython. Should
 	extend it later for grace access too. Inspired by Arnd's
 	suggestion.
 
 	* IPython/iplib.py (InteractiveShell.handle_magic): fixed bug when
 	calling magic functions with () in their arguments. Thanks to Arnd
 	Baecker for pointing this to me.
 
 	* IPython/numutils.py (sum_flat): fixed bug. Would recurse
 	infinitely for integer or complex arrays (only worked with floats).
 
 2002-03-16  Fernando Perez  <[e-mail]>
 
 	* setup.py: Merged setup and setup_windows into a single script
 	which properly handles things for windows users.
 
 2002-03-15  Fernando Perez  <[e-mail]>
 
 	* Big change to the manual: now the magics are all automatically
 	documented. This information is generated from their docstrings
 	and put in a latex file included by the manual lyx file. This way
 	we get always up to date information for the magics. The manual
 	now also has proper version information, also auto-synced.
 
 	For this to work, an undocumented --magic_docstrings option was added.
 
 2002-03-13  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (TermColors): fixed problem with dark colors
 	under CDE terminals. An explicit ;2 color reset is needed in the escapes.
 
 2002-03-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (TermColors): changed color escapes again to
 	fix the (old, reintroduced) line-wrapping bug. Basically, if
 	\001..\002 aren't given in the color escapes, lines get wrapped
 	weirdly. But giving those screws up old xterms and emacs terms. So
 	I added some logic for emacs terms to be ok, but I can't identify old
 	xterms separately ($TERM=='xterm' for many terminals, like konsole).
 
 2002-03-10  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): Various documentation cleanups and
 	updates, both in usage docstrings and in the manual.
 
 	* IPython/Prompts.py (CachedOutput.set_colors): cleanups for
 	handling of caching. Set minimum acceptabe value for having a
 	cache at 20 values.
 
 	* IPython/iplib.py (InteractiveShell.user_setup): moved the
 	install_first_time function to a method, renamed it and added an
 	'upgrade' mode. Now people can update their config directory with
 	a simple command line switch (-upgrade, also new).
 
 	* IPython/Magic.py (Magic.magic_pfile): Made @pfile an alias to
 	@file (convenient for automagic users under Python >= 2.2). 
 	Removed @files (it seemed more like a plural than an abbrev. of
 	'file show').
 
 	* IPython/iplib.py (install_first_time): Fixed crash if there were
 	backup files ('~') in .ipython/ install directory.
 
 	* IPython/ipmaker.py (make_IPython): fixes for new prompt
 	system. Things look fine, but these changes are fairly
 	intrusive. Test them for a few days.
 
 	* IPython/Prompts.py (CachedOutput.__init__): Massive rewrite of
 	the prompts system. Now all in/out prompt strings are user
 	controllable. This is particularly useful for embedding, as one
 	can tag embedded instances with particular prompts. 
 
 	Also removed global use of sys.ps1/2, which now allows nested
 	embeddings without any problems. Added command-line options for
 	the prompt strings.
 
 2002-03-08  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/example-embed-short.py (ipshell): added
 	example file with the bare minimum code for embedding.
 
 	* IPython/Shell.py (IPythonShellEmbed.set_dummy_mode): added
 	functionality for the embeddable shell to be activated/deactivated
 	either globally or at each call.
 
 	* IPython/Prompts.py (Prompt1.auto_rewrite): Fixes the problem of
 	rewriting the prompt with '--->' for auto-inputs with proper
 	coloring. Now the previous UGLY hack in handle_auto() is gone, and
 	this is handled by the prompts class itself, as it should.
 
 2002-03-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_logstart): Changed @log to
 	@logstart to avoid name clashes with the math log function.
 
 	* Big updates to X/Emacs section of the manual.
 
 	* Removed ipython_emacs. Milan explained to me how to pass
 	arguments to ipython through Emacs. Some day I'm going to end up
 	learning some lisp...
 
 2002-03-04  Fernando Perez  <[e-mail]>
 
 	* IPython/ipython_emacs: Created script to be used as the
 	py-python-command Emacs variable so we can pass IPython
 	parameters. I can't figure out how to tell Emacs directly to pass
 	parameters to IPython, so a dummy shell script will do it.
 
 	Other enhancements made for things to work better under Emacs'
 	various types of terminals. Many thanks to Milan Zamazal
 	<pdm-AT-zamazal.org> for all the suggestions and pointers.
 
 2002-03-01  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): added a --readline! option so
 	that loading of readline is now optional. This gives better
 	control to emacs users.
 
 	* IPython/ultraTB.py (__date__): Modified color escape sequences
 	and now things work fine under xterm and in Emacs' term buffers
 	(though not shell ones). Well,  in emacs you get colors, but all
 	seem to be 'light' colors (no difference between dark and light
 	ones). But the garbage chars are gone, and also in xterms. It
 	seems that now I'm using 'cleaner' ansi sequences.
 
 2002-02-21  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.7 (mainly to publish the scoping fix).
 	
 	* IPython/Logger.py (Logger.logstate): added. A corresponding
 	@logstate magic was created.
 
 	* IPython/Magic.py: fixed nested scoping problem under Python
 	2.1.x (automagic wasn't working).
 
 2002-02-20  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.6.
 
 	* IPython/OutputTrap.py (OutputTrap.__init__): added a 'quiet'
 	option so that logs can come out without any headers at all.
 
 	* IPython/UserConfig/ipythonrc-scipy.py: created a profile for
 	SciPy.
 
 	* IPython/iplib.py (InteractiveShell.embed_mainloop): Changed so
 	that embedded IPython calls don't require vars() to be explicitly
 	passed. Now they are extracted from the caller's frame (code
 	snatched from Eric Jones' weave). Added better documentation to
 	the section on embedding and the example file.
 
 	* IPython/genutils.py (page): Changed so that under emacs, it just
 	prints the string. You can then page up and down in the emacs
 	buffer itself. This is how the builtin help() works.
 
 	* IPython/Prompts.py (CachedOutput.__call__): Fixed issue with
 	macro scoping: macros need to be executed in the user's namespace
 	to work as if they had been typed by the user.
 
 	* IPython/Magic.py (Magic.magic_macro): Changed macros so they
 	execute automatically (no need to type 'exec...'). They then
 	behave like 'true macros'. The printing system was also modified
 	for this to work.
 
 2002-02-19  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page_file): new function for paging files
 	in an OS-independent way. Also necessary for file viewing to work
 	well inside Emacs buffers.
 	(page): Added checks for being in an emacs buffer.
 	(page): fixed bug for Windows ($TERM isn't set in Windows). Fixed
 	same bug in iplib.
 
 2002-02-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.init_readline): modified use
 	of readline so that IPython can work inside an Emacs buffer.
 
 	* IPython/ultraTB.py (AutoFormattedTB.__call__): some fixes to
 	method signatures (they weren't really bugs, but it looks cleaner
 	and keeps PyChecker happy).
 
 	* IPython/ipmaker.py (make_IPython): added hooks Struct to __IP
 	for implementing various user-defined hooks. Currently only
 	display is done.
 
 	* IPython/Prompts.py (CachedOutput._display): changed display
 	functions so that they can be dynamically changed by users easily.
 
 	* IPython/Extensions/numeric_formats.py (num_display): added an
 	extension for printing NumPy arrays in flexible manners. It
 	doesn't do anything yet, but all the structure is in
 	place. Ultimately the plan is to implement output format control
 	like in Octave.
 
 	* IPython/Magic.py (Magic.lsmagic): changed so that bound magic
 	methods are found at run-time by all the automatic machinery.
 
 2002-02-17  Fernando Perez  <[e-mail]>
 
 	* setup_Windows.py (make_shortcut): documented. Cleaned up the
 	whole file a little.
 
 	* ToDo: closed this document. Now there's a new_design.lyx
 	document for all new ideas. Added making a pdf of it for the
 	end-user distro.
 
 	* IPython/Logger.py (Logger.switch_log): Created this to replace
 	logon() and logoff(). It also fixes a nasty crash reported by 
 	Philip Hisley <compsys-AT-starpower.net>. Many thanks to him.
 
 	* IPython/iplib.py (complete): got auto-completion to work with
 	automagic (I had wanted this for a long time).
 
 	* IPython/Magic.py (Magic.magic_files): Added @files as an alias
 	to @file, since file() is now a builtin and clashes with automagic
 	for @file.
 
 	* Made some new files: Prompts, CrashHandler, Magic, Logger. All
 	of this was previously in iplib, which had grown to more than 2000
 	lines, way too long. No new functionality, but it makes managing
 	the code a bit easier.
 
 	* IPython/iplib.py (IPythonCrashHandler.__call__): Added version
 	information to crash reports.
 
 2002-02-12  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.5.
 
 2002-02-11  Fernando Perez  <[e-mail]>
 
 	* Wrote a relatively complete Windows installer. It puts
 	everything in place, creates Start Menu entries and fixes the
 	color issues. Nothing fancy, but it works.
 
 2002-02-10  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): added an
 	os.path.expanduser() call so that we can type @run ~/myfile.py and
 	have thigs work as expected.
 
 	* IPython/genutils.py (page): fixed exception handling so things
 	work both in Unix and Windows correctly. Quitting a pager triggers
 	an IOError/broken pipe in Unix, and in windows not finding a pager
 	is also an IOError, so I had to actually look at the return value
 	of the exception, not just the exception itself. Should be ok now.
 
 	* IPython/ultraTB.py (ColorSchemeTable.set_active_scheme):
 	modified to allow case-insensitive color scheme changes.
 
 2002-02-09  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (native_line_ends): new function to leave
 	user config files with os-native line-endings.
 
 	* README and manual updates.
 
 	* IPython/genutils.py: fixed unicode bug: use types.StringTypes
 	instead of StringType to catch Unicode strings.
 
 	* IPython/genutils.py (filefind): fixed bug for paths with
 	embedded spaces (very common in Windows).
 
 	* IPython/ipmaker.py (make_IPython): added a '.ini' to the rc
 	files under Windows, so that they get automatically associated
 	with a text editor. Windows makes it a pain to handle
 	extension-less files.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): Made the
 	warning about readline only occur for Posix. In Windows there's no
 	way to get readline, so why bother with the warning.
 
 	* IPython/Struct.py (Struct.__str__): fixed to use self.__dict__
 	for __str__ instead of dir(self), since dir() changed in 2.2.
 
 	* Ported to Windows! Tested on XP, I suspect it should work fine
 	on NT/2000, but I don't think it will work on 98 et al. That
 	series of Windows is such a piece of junk anyway that I won't try
 	porting it there. The XP port was straightforward, showed a few
 	bugs here and there (fixed all), in particular some string
 	handling stuff which required considering Unicode strings (which
 	Windows uses). This is good, but hasn't been too tested :) No
 	fancy installer yet, I'll put a note in the manual so people at
 	least make manually a shortcut.
 
 	* IPython/iplib.py (Magic.magic_colors): Unified the color options
 	into a single one, "colors". This now controls both prompt and
 	exception color schemes, and can be changed both at startup
 	(either via command-line switches or via ipythonrc files) and at
 	runtime, with @colors.
 	(Magic.magic_run): renamed @prun to @run and removed the old
 	@run. The two were too similar to warrant keeping both.
 
 2002-02-03  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (install_first_time): Added comment on how to
 	configure the color options for first-time users. Put a <return>
 	request at the end so that small-terminal users get a chance to
 	read the startup info.
 
 2002-01-23  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (CachedOutput.update): Changed output memory
 	variable names from _o,_oo,_ooo,_o<n> to simply _,__,___,_<n>. For
 	input history we still use _i. Did this b/c these variable are
 	very commonly used in interactive work, so the less we need to
 	type the better off we are.
 	(Magic.magic_prun): updated @prun to better handle the namespaces
 	the file will run in, including a fix for __name__ not being set
 	before.
 
 2002-01-20  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.linereader): Fixed printing of
 	extra garbage for Python 2.2. Need to look more carefully into
 	this later.
 
 2002-01-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.showtraceback): fixed to
 	display SyntaxError exceptions properly formatted when they occur
 	(they can be triggered by imported code).
 
 2002-01-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): now
 	SyntaxError exceptions are reported nicely formatted, instead of
 	spitting out only offset information as before.
 	(Magic.magic_prun): Added the @prun function for executing
 	programs with command line args inside IPython.
 
 2002-01-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (Magic.magic_hist): Changed @hist and @dhist
 	to *not* include the last item given in a range. This brings their
 	behavior in line with Python's slicing: 
 	  a[n1:n2] -> a[n1]...a[n2-1]
 	It may be a bit less convenient, but I prefer to stick to Python's
 	conventions *everywhere*, so users never have to wonder.
 	(Magic.magic_macro): Added @macro function to ease the creation of
 	macros.
 
 2002-01-05  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.4.
 
 	* IPython/iplib.py (Magic.magic_pdef): 
 	(InteractiveShell.safe_execfile): report magic lines and error
 	lines without line numbers so one can easily copy/paste them for
 	re-execution.
 
 	* Updated manual with recent changes.
 
 	* IPython/iplib.py (Magic.magic_oinfo): added constructor
 	docstring printing when class? is called. Very handy for knowing
 	how to create class instances (as long as __init__ is well
 	documented, of course :)
 	(Magic.magic_doc): print both class and constructor docstrings.
 	(Magic.magic_pdef): give constructor info if passed a class and
 	__call__ info for callable object instances.
 
 2002-01-04  Fernando Perez  <[e-mail]>
 
 	* Made deep_reload() off by default. It doesn't always work
 	exactly as intended, so it's probably safer to have it off. It's
 	still available as dreload() anyway, so nothing is lost.
 
 2002-01-02  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.3 (contacted R.Singh at CU about biopython course,
 	so I wanted an updated release).
 
 2001-12-27  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): Added the original
 	code from 'code.py' for this module in order to change the
 	handling of a KeyboardInterrupt. This was necessary b/c otherwise
 	the history cache would break when the user hit Ctrl-C, and
 	interact() offers no way to add any hooks to it.
 
 2001-12-23  Fernando Perez  <[e-mail]>
 
 	* setup.py: added check for 'MANIFEST' before trying to remove
 	it. Thanks to Sean Reifschneider.
 
 2001-12-22  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.2.
 
 	* Finished (reasonably) writing the manual. Later will add the
 	python-standard navigation stylesheets, but for the time being
 	it's fairly complete. Distribution will include html and pdf
 	versions.
 
 	* Bugfix: '.' wasn't being added to sys.path. Thanks to Prabhu
 	(MayaVi author).
 
 2001-12-21  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.1. Barring any nasty bugs, this is it as far as a
 	good public release, I think (with the manual and the distutils
 	installer). The manual can use some work, but that can go
 	slowly. Otherwise I think it's quite nice for end users. Next
 	summer, rewrite the guts of it...
 
 	* Changed format of ipythonrc files to use whitespace as the
 	separator instead of an explicit '='. Cleaner.
 
 2001-12-20  Fernando Perez  <[e-mail]>
 
 	* Started a manual in LyX. For now it's just a quick merge of the
 	various internal docstrings and READMEs. Later it may grow into a
 	nice, full-blown manual.
 
 	* Set up a distutils based installer. Installation should now be
 	trivially simple for end-users.
 
 2001-12-11  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.0. First public release, announced it at
 	comp.lang.python. From now on, just bugfixes...
 
 	* Went through all the files, set copyright/license notices and
 	cleaned up things. Ready for release.
 
 2001-12-10  Fernando Perez  <[e-mail]>
 
 	* Changed the first-time installer not to use tarfiles. It's more
 	robust now and less unix-dependent. Also makes it easier for
 	people to later upgrade versions.
 
 	* Changed @exit to @abort to reflect the fact that it's pretty
 	brutal (a sys.exit()). The difference between @abort and Ctrl-D
 	becomes significant only when IPyhton is embedded: in that case,
 	C-D closes IPython only, but @abort kills the enclosing program
 	too (unless it had called IPython inside a try catching
 	SystemExit).
 
 	* Created Shell module which exposes the actuall IPython Shell
 	classes, currently the normal and the embeddable one. This at
 	least offers a stable interface we won't need to change when
 	(later) the internals are rewritten. That rewrite will be confined
 	to iplib and ipmaker, but the Shell interface should remain as is.
 
 	* Added embed module which offers an embeddable IPShell object,
 	useful to fire up IPython *inside* a running program. Great for
 	debugging or dynamical data analysis.
 
 2001-12-08  Fernando Perez  <[e-mail]>
 
 	* Fixed small bug preventing seeing info from methods of defined
 	objects (incorrect namespace in _ofind()).
 
 	* Documentation cleanup. Moved the main usage docstrings to a
 	separate file, usage.py (cleaner to maintain, and hopefully in the
 	future some perlpod-like way of producing interactive, man and
 	html docs out of it will be found).
 
 	* Added @profile to see your profile at any time.
 
 	* Added @p as an alias for 'print'. It's especially convenient if
 	using automagic ('p x' prints x).
 
 	* Small cleanups and fixes after a pychecker run.
 
 	* Changed the @cd command to handle @cd - and @cd -<n> for
 	visiting any directory in _dh.
 
 	* Introduced _dh, a history of visited directories. @dhist prints
 	it out with numbers.
 
 2001-12-07  Fernando Perez  <[e-mail]>
 
 	* Released 0.1.22
 
 	* Made initialization a bit more robust against invalid color
 	options in user input (exit, not traceback-crash).
 
 	* Changed the bug crash reporter to write the report only in the
 	user's .ipython directory. That way IPython won't litter people's
 	hard disks with crash files all over the place. Also print on
 	screen the necessary mail command.
 
 	* With the new ultraTB, implemented LightBG color scheme for light
 	background terminals. A lot of people like white backgrounds, so I
 	guess we should at least give them something readable.
 
 2001-12-06  Fernando Perez  <[e-mail]>
 
 	* Modified the structure of ultraTB. Now there's a proper class
 	for tables of color schemes which allow adding schemes easily and
 	switching the active scheme without creating a new instance every
 	time (which was ridiculous). The syntax for creating new schemes
 	is also cleaner. I think ultraTB is finally done, with a clean
 	class structure. Names are also much cleaner (now there's proper
 	color tables, no need for every variable to also have 'color' in
 	its name).
 
 	* Broke down genutils into separate files. Now genutils only
 	contains utility functions, and classes have been moved to their
 	own files (they had enough independent functionality to warrant
 	it): ConfigLoader, OutputTrap, Struct.
 
 2001-12-05  Fernando Perez  <[e-mail]>
 
 	* IPython turns 21! Released version 0.1.21, as a candidate for
 	public consumption. If all goes well, release in a few days.
 
 	* Fixed path bug (files in Extensions/ directory wouldn't be found
 	unless IPython/ was explicitly in sys.path).
 
 	* Extended the FlexCompleter class as MagicCompleter to allow
 	completion of @-starting lines.
 
 	* Created __release__.py file as a central repository for release
 	info that other files can read from.
 
 	* Fixed small bug in logging: when logging was turned on in
 	mid-session, old lines with special meanings (!@?) were being
 	logged without the prepended comment, which is necessary since
 	they are not truly valid python syntax. This should make session
 	restores produce less errors.
 
 	* The namespace cleanup forced me to make a FlexCompleter class
 	which is nothing but a ripoff of rlcompleter, but with selectable
 	namespace (rlcompleter only works in __main__.__dict__). I'll try
 	to submit a note to the authors to see if this change can be
 	incorporated in future rlcompleter releases (Dec.6: done)
 
 	* More fixes to namespace handling. It was a mess! Now all
 	explicit references to __main__.__dict__ are gone (except when
 	really needed) and everything is handled through the namespace
 	dicts in the IPython instance. We seem to be getting somewhere
 	with this, finally...
 
 	* Small documentation updates.
 
 	* Created the Extensions directory under IPython (with an
 	__init__.py). Put the PhysicalQ stuff there. This directory should
 	be used for all special-purpose extensions.
 
 	* File renaming:
 	  ipythonlib --> ipmaker
 	  ipplib     --> iplib
 	This makes a bit more sense in terms of what these files actually do.
 
 	* Moved all the classes and functions in ipythonlib to ipplib, so
 	now ipythonlib only has make_IPython(). This will ease up its
 	splitting in smaller functional chunks later.
 
 	* Cleaned up (done, I think) output of @whos. Better column
 	formatting, and now shows str(var) for as much as it can, which is
 	typically what one gets with a 'print var'.
 
 2001-12-04  Fernando Perez  <[e-mail]>
 
 	* Fixed namespace problems. Now builtin/IPyhton/user names get
 	properly reported in their namespace. Internal namespace handling
 	is finally getting decent (not perfect yet, but much better than
 	the ad-hoc mess we had).
 
 	* Removed -exit option. If people just want to run a python
 	script, that's what the normal interpreter is for. Less
 	unnecessary options, less chances for bugs.
 
 	* Added a crash handler which generates a complete post-mortem if
 	IPython crashes. This will help a lot in tracking bugs down the
 	road.
 
 	* Fixed nasty bug in auto-evaluation part of prefilter(). Names
 	which were boud to functions being reassigned would bypass the
 	logger, breaking the sync of _il with the prompt counter. This
 	would then crash IPython later when a new line was logged.
 
 2001-12-02  Fernando Perez  <[e-mail]>
 
 	* Made IPython a package. This means people don't have to clutter
 	their sys.path with yet another directory. Changed the INSTALL
 	file accordingly.
 
 	* Cleaned up the output of @who_ls, @who and @whos. @who_ls now
 	sorts its output (so @who shows it sorted) and @whos formats the
 	table according to the width of the first column. Nicer, easier to
 	read. Todo: write a generic table_format() which takes a list of
 	lists and prints it nicely formatted, with optional row/column
 	separators and proper padding and justification. 
 
 	* Released 0.1.20
 
 	* Fixed bug in @log which would reverse the inputcache list (a
 	copy operation was missing).
 
 	* Code cleanup. @config was changed to use page(). Better, since
 	its output is always quite long.
 
 	* Itpl is back as a dependency. I was having too many problems
 	getting the parametric aliases to work reliably, and it's just
 	easier to code weird string operations with it than playing %()s
 	games. It's only ~6k, so I don't think it's too big a deal.
 
 	* Found (and fixed) a very nasty bug with history. !lines weren't
 	getting cached, and the out of sync caches would crash
 	IPython. Fixed it by reorganizing the prefilter/handlers/logger
 	division of labor a bit better. Bug fixed, cleaner structure.
 
 2001-12-01  Fernando Perez  <[e-mail]>
 
 	* Released 0.1.19
 
 	* Added option -n to @hist to prevent line number printing. Much
 	easier to copy/paste code this way.
 
 	* Created global _il to hold the input list. Allows easy
 	re-execution of blocks of code by slicing it (inspired by Janko's
 	comment on 'macros').
 
 	* Small fixes and doc updates.
 
 	* Rewrote @history function (was @h). Renamed it to @hist, @h is
 	much too fragile with automagic. Handles properly multi-line
 	statements and takes parameters.
 
 2001-11-30  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.18 released.
 
 	* Fixed nasty namespace bug in initial module imports.
 
 	* Added copyright/license notes to all code files (except
 	DPyGetOpt). For the time being, LGPL. That could change.
 
 	* Rewrote a much nicer README, updated INSTALL, cleaned up
 	ipythonrc-* samples.
 
 	* Overall code/documentation cleanup. Basically ready for
 	release. Only remaining thing: licence decision (LGPL?).
 
 	* Converted load_config to a class, ConfigLoader. Now recursion
 	control is better organized. Doesn't include the same file twice.
 
 2001-11-29  Fernando Perez  <[e-mail]>
 
 	* Got input history working. Changed output history variables from
 	_p to _o so that _i is for input and _o for output. Just cleaner
 	convention.
 
 	* Implemented parametric aliases. This pretty much allows the
 	alias system to offer full-blown shell convenience, I think.
 
 	* Version 0.1.17 released, 0.1.18 opened.
 
 	* dot_ipython/ipythonrc (alias): added documentation.
 	(xcolor): Fixed small bug (xcolors -> xcolor)
 
 	* Changed the alias system. Now alias is a magic command to define
 	aliases just like the shell. Rationale: the builtin magics should
 	be there for things deeply connected to IPython's
 	architecture. And this is a much lighter system for what I think
 	is the really important feature: allowing users to define quickly
 	magics that will do shell things for them, so they can customize
 	IPython easily to match their work habits. If someone is really
 	desperate to have another name for a builtin alias, they can
 	always use __IP.magic_newname = __IP.magic_oldname. Hackish but
 	works.
 
 2001-11-28  Fernando Perez  <[e-mail]>
 
 	* Changed @file so that it opens the source file at the proper
 	line. Since it uses less, if your EDITOR environment is
 	configured, typing v will immediately open your editor of choice
 	right at the line where the object is defined. Not as quick as
 	having a direct @edit command, but for all intents and purposes it
 	works. And I don't have to worry about writing @edit to deal with
 	all the editors, less does that.
 
 	* Version 0.1.16 released, 0.1.17 opened.
 
 	* Fixed some nasty bugs in the page/page_dumb combo that could
 	crash IPython.
 
 2001-11-27  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.15 released, 0.1.16 opened.
 
 	* Finally got ? and ?? to work for undefined things: now it's
 	possible to type {}.get? and get information about the get method
 	of dicts, or os.path? even if only os is defined (so technically
 	os.path isn't). Works at any level. For example, after import os,
 	os?, os.path?, os.path.abspath? all work. This is great, took some
 	work in _ofind.
 
 	* Fixed more bugs with logging. The sanest way to do it was to add
 	to @log a 'mode' parameter. Killed two in one shot (this mode
 	option was a request of Janko's). I think it's finally clean
 	(famous last words).
 
 	* Added a page_dumb() pager which does a decent job of paging on
 	screen, if better things (like less) aren't available. One less
 	unix dependency (someday maybe somebody will port this to
 	windows).
 
 	* Fixed problem in magic_log: would lock of logging out if log
 	creation failed (because it would still think it had succeeded).
 
 	* Improved the page() function using curses to auto-detect screen
 	size. Now it can make a much better decision on whether to print
 	or page a string. Option screen_length was modified: a value 0
 	means auto-detect, and that's the default now.
 
 	* Version 0.1.14 released, 0.1.15 opened. I think this is ready to
 	go out. I'll test it for a few days, then talk to Janko about
 	licences and announce it.
 
 	* Fixed the length of the auto-generated ---> prompt which appears
 	for auto-parens and auto-quotes. Getting this right isn't trivial,
 	with all the color escapes, different prompt types and optional
 	separators. But it seems to be working in all the combinations.
 
 2001-11-26  Fernando Perez  <[e-mail]>
 
 	* Wrote a regexp filter to get option types from the option names
 	string. This eliminates the need to manually keep two duplicate
 	lists.
 
 	* Removed the unneeded check_option_names. Now options are handled
 	in a much saner manner and it's easy to visually check that things
 	are ok.
 
 	* Updated version numbers on all files I modified to carry a
 	notice so Janko and Nathan have clear version markers.
 
 	* Updated docstring for ultraTB with my changes. I should send
 	this to Nathan.
 
 	* Lots of small fixes. Ran everything through pychecker again.
 
 	* Made loading of deep_reload an cmd line option. If it's not too
 	kosher, now people can just disable it. With -nodeep_reload it's
 	still available as dreload(), it just won't overwrite reload().
 
 	* Moved many options to the no| form (-opt and -noopt
 	accepted). Cleaner.
 
 	* Changed magic_log so that if called with no parameters, it uses
 	'rotate' mode. That way auto-generated logs aren't automatically
 	over-written. For normal logs, now a backup is made if it exists
 	(only 1 level of backups). A new 'backup' mode was added to the
 	Logger class to support this. This was a request by Janko.
 
 	* Added @logoff/@logon to stop/restart an active log.
 
 	* Fixed a lot of bugs in log saving/replay. It was pretty
 	broken. Now special lines (!@,/) appear properly in the command
 	history after a log replay.
 
 	* Tried and failed to implement full session saving via pickle. My
 	idea was to pickle __main__.__dict__, but modules can't be
 	pickled. This would be a better alternative to replaying logs, but
 	seems quite tricky to get to work. Changed -session to be called
 	-logplay, which more accurately reflects what it does. And if we
 	ever get real session saving working, -session is now available.
 
 	* Implemented color schemes for prompts also. As for tracebacks,
 	currently only NoColor and Linux are supported. But now the
 	infrastructure is in place, based on a generic ColorScheme
 	class. So writing and activating new schemes both for the prompts
 	and the tracebacks should be straightforward.
 
 	* Version 0.1.13 released, 0.1.14 opened.
 
 	* Changed handling of options for output cache. Now counter is
 	hardwired starting at 1 and one specifies the maximum number of
 	entries *in the outcache* (not the max prompt counter). This is
 	much better, since many statements won't increase the cache
 	count. It also eliminated some confusing options, now there's only
 	one: cache_size.
 
 	* Added 'alias' magic function and magic_alias option in the
 	ipythonrc file. Now the user can easily define whatever names he
 	wants for the magic functions without having to play weird
 	namespace games. This gives IPython a real shell-like feel.
 
 	* Fixed doc/?/?? for magics. Now all work, in all forms (explicit
 	@ or not).
 
 	This was one of the last remaining 'visible' bugs (that I know
 	of). I think if I can clean up the session loading so it works
 	100% I'll release a 0.2.0 version on c.p.l (talk to Janko first
 	about licensing).	
 
 2001-11-25  Fernando Perez  <[e-mail]>
 
 	* Rewrote somewhat oinfo (?/??). Nicer, now uses page() and
 	there's a cleaner distinction between what ? and ?? show.
 
 	* Added screen_length option. Now the user can define his own
 	screen size for page() operations.
 
 	* Implemented magic shell-like functions with automatic code
 	generation. Now adding another function is just a matter of adding
 	an entry to a dict, and the function is dynamically generated at
 	run-time. Python has some really cool features!
 
 	* Renamed many options to cleanup conventions a little. Now all
 	are lowercase, and only underscores where needed. Also in the code
 	option name tables are clearer.
 
 	* Changed prompts a little. Now input is 'In [n]:' instead of
 	'In[n]:='. This allows it the numbers to be aligned with the
 	Out[n] numbers, and removes usage of ':=' which doesn't exist in
 	Python (it was a Mathematica thing). The '...' continuation prompt
 	was also changed a little to align better.
 
 	* Fixed bug when flushing output cache. Not all _p<n> variables
 	exist, so their deletion needs to be wrapped in a try:
 
 	* Figured out how to properly use inspect.formatargspec() (it
 	requires the args preceded by *). So I removed all the code from
 	_get_pdef in Magic, which was just replicating that.
 
 	* Added test to prefilter to allow redefining magic function names
 	as variables. This is ok, since the @ form is always available,
 	but whe should allow the user to define a variable called 'ls' if
 	he needs it.
 
 	* Moved the ToDo information from README into a separate ToDo.
 
 	* General code cleanup and small bugfixes. I think it's close to a
 	state where it can be released, obviously with a big 'beta'
 	warning on it.
 
 	* Got the magic function split to work. Now all magics are defined
 	in a separate class. It just organizes things a bit, and now
 	Xemacs behaves nicer (it was choking on InteractiveShell b/c it
 	was too long).
 
 	* Changed @clear to @reset to avoid potential confusions with
 	the shell command clear. Also renamed @cl to @clear, which does
 	exactly what people expect it to from their shell experience.
 
 	Added a check to the @reset command (since it's so
 	destructive, it's probably a good idea to ask for confirmation).
 	But now reset only works for full namespace resetting. Since the
 	del keyword is already there for deleting a few specific
 	variables, I don't see the point of having a redundant magic
 	function for the same task.
 
 2001-11-24  Fernando Perez  <[e-mail]>
 
 	* Updated the builtin docs (esp. the ? ones).
 
 	* Ran all the code through pychecker. Not terribly impressed with
 	it: lots of spurious warnings and didn't really find anything of
 	substance (just a few modules being imported and not used).
 
 	* Implemented the new ultraTB functionality into IPython. New
 	option: xcolors. This chooses color scheme. xmode now only selects
 	between Plain and Verbose. Better orthogonality.
 
 	* Large rewrite of ultraTB. Much cleaner now, with a separation of
 	mode and color scheme for the exception handlers. Now it's
 	possible to have the verbose traceback with no coloring.
 
 2001-11-23  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.12 released, 0.1.13 opened.
 
 	* Removed option to set auto-quote and auto-paren escapes by
 	user. The chances of breaking valid syntax are just too high. If
 	someone *really* wants, they can always dig into the code.
 
 	* Made prompt separators configurable.
 
 2001-11-22  Fernando Perez  <[e-mail]>
 
 	* Small bugfixes in many places.
 
 	* Removed the MyCompleter class from ipplib. It seemed redundant
 	with the C-p,C-n history search functionality. Less code to
 	maintain.
 
 	* Moved all the original ipython.py code into ipythonlib.py. Right
 	now it's just one big dump into a function called make_IPython, so
 	no real modularity has been gained. But at least it makes the
 	wrapper script tiny, and since ipythonlib is a module, it gets
 	compiled and startup is much faster.
 
 	This is a reasobably 'deep' change, so we should test it for a
 	while without messing too much more with the code.
 
 2001-11-21  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.11 released, 0.1.12 opened for further work.
 
 	* Removed dependency on Itpl. It was only needed in one place. It
 	would be nice if this became part of python, though. It makes life
 	*a lot* easier in some cases.
 
 	* Simplified the prefilter code a bit. Now all handlers are
 	expected to explicitly return a value (at least a blank string).
 
 	* Heavy edits in ipplib. Removed the help system altogether. Now
 	obj?/?? is used for inspecting objects, a magic @doc prints
 	docstrings, and full-blown Python help is accessed via the 'help'
 	keyword. This cleans up a lot of code (less to maintain) and does
 	the job. Since 'help' is now a standard Python component, might as
 	well use it and remove duplicate functionality.
 
 	Also removed the option to use ipplib as a standalone program. By
 	now it's too dependent on other parts of IPython to function alone.
 
 	* Fixed bug in genutils.pager. It would crash if the pager was
 	exited immediately after opening (broken pipe).
 
 	* Trimmed down the VerboseTB reporting a little. The header is
 	much shorter now and the repeated exception arguments at the end
 	have been removed. For interactive use the old header seemed a bit
 	excessive.
 
 	* Fixed small bug in output of @whos for variables with multi-word
 	types (only first word was displayed).
 
 2001-11-17  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.10 released, 0.1.11 opened for further work.
 
 	* Modified dirs and friends. dirs now *returns* the stack (not
 	prints), so one can manipulate it as a variable. Convenient to
 	travel along many directories.
 
 	* Fixed bug in magic_pdef: would only work with functions with
 	arguments with default values.
 
 2001-11-14  Fernando Perez  <[e-mail]>
 
 	* Added the PhysicsInput stuff to dot_ipython so it ships as an
 	example with IPython. Various other minor fixes and cleanups.
 
 	* Version 0.1.9 released, 0.1.10 opened for further work.
 
 	* Added sys.path to the list of directories searched in the
 	execfile= option. It used to be the current directory and the
 	user's IPYTHONDIR only.
 
 2001-11-13  Fernando Perez  <[e-mail]>
 
 	* Reinstated the raw_input/prefilter separation that Janko had
 	initially. This gives a more convenient setup for extending the
 	pre-processor from the outside: raw_input always gets a string,
 	and prefilter has to process it. We can then redefine prefilter
 	from the outside and implement extensions for special
 	purposes.
 
 	Today I got one for inputting PhysicalQuantity objects
 	(from Scientific) without needing any function calls at
 	all. Extremely convenient, and it's all done as a user-level
 	extension (no IPython code was touched). Now instead of:
 		a = PhysicalQuantity(4.2,'m/s**2')
 	one can simply say
 		a = 4.2 m/s**2
 	or even
 		a = 4.2 m/s^2
 	
 	I use this, but it's also a proof of concept: IPython really is
 	fully user-extensible, even at the level of the parsing of the
 	command line. It's not trivial, but it's perfectly doable.
 
 	* Added 'add_flip' method to inclusion conflict resolver. Fixes
 	the problem of modules being loaded in the inverse order in which
 	they were defined in 
 
 	* Version 0.1.8 released, 0.1.9 opened for further work.
 
 	* Added magics pdef, source and file. They respectively show the
 	definition line ('prototype' in C), source code and full python
 	file for any callable object. The object inspector oinfo uses
 	these to show the same information.
 
 	* Version 0.1.7 released, 0.1.8 opened for further work.
 
 	* Separated all the magic functions into a class called Magic. The
 	InteractiveShell class was becoming too big for Xemacs to handle
 	(de-indenting a line would lock it up for 10 seconds while it
 	backtracked on the whole class!)
 
 	FIXME: didn't work. It can be done, but right now namespaces are
 	all messed up. Do it later (reverted it for now, so at least
 	everything works as before).
 
 	* Got the object introspection system (magic_oinfo) working! I
 	think this is pretty much ready for release to Janko, so he can
 	test it for a while and then announce it. Pretty much 100% of what
 	I wanted for the 'phase 1' release is ready. Happy, tired.
 
 2001-11-12  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.6 released, 0.1.7 opened for further work.
 
 	* Fixed bug in printing: it used to test for truth before
 	printing, so 0 wouldn't print. Now checks for None.
 
 	* Fixed bug where auto-execs increase the prompt counter by 2 (b/c
 	they have to call len(str(sys.ps1)) ). But the fix is ugly, it
 	reaches by hand into the outputcache. Think of a better way to do
 	this later.
 
 	* Various small fixes thanks to Nathan's comments.
 
 	* Changed magic_pprint to magic_Pprint. This way it doesn't
 	collide with pprint() and the name is consistent with the command
 	line option.
 
 	* Changed prompt counter behavior to be fully like
 	Mathematica's. That is, even input that doesn't return a result
 	raises the prompt counter. The old behavior was kind of confusing
 	(getting the same prompt number several times if the operation
 	didn't return a result).
 
 	* Fixed Nathan's last name in a couple of places (Gray, not Graham).
 
 	* Fixed -Classic mode (wasn't working anymore).
 
 	* Added colored prompts using Nathan's new code. Colors are
 	currently hardwired, they can be user-configurable. For
 	developers, they can be chosen in file ipythonlib.py, at the
 	beginning of the CachedOutput class def.
 
 2001-11-11  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.5 released, 0.1.6 opened for further work.
 
 	* Changed magic_env to *return* the environment as a dict (not to
 	print it). This way it prints, but it can also be processed.
 
 	* Added Verbose exception reporting to interactive
 	exceptions. Very nice, now even 1/0 at the prompt gives a verbose
 	traceback. Had to make some changes to the ultraTB file. This is
 	probably the last 'big' thing in my mental todo list.  This ties
 	in with the next entry:
 
 	* Changed -Xi and -Xf to a single -xmode option. Now all the user
 	has to specify is Plain, Color or Verbose for all exception
 	handling.
 
 	* Removed ShellServices option. All this can really be done via
 	the magic system. It's easier to extend, cleaner and has automatic
 	namespace protection and documentation.
 
 2001-11-09  Fernando Perez  <[e-mail]>
 
 	* Fixed bug in output cache flushing (missing parameter to
 	__init__). Other small bugs fixed (found using pychecker).
 
 	* Version 0.1.4 opened for bugfixing.
 
 2001-11-07  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.3 released, mainly because of the raw_input bug.
 
 	* Fixed NASTY bug in raw_input: input line wasn't properly parsed
 	and when testing for whether things were callable, a call could
 	actually be made to certain functions. They would get called again
 	once 'really' executed, with a resulting double call. A disaster
 	in many cases (list.reverse() would never work!).
 
 	* Removed prefilter() function, moved its code to raw_input (which
 	after all was just a near-empty caller for prefilter). This saves
 	a function call on every prompt, and simplifies the class a tiny bit.
 
 	* Fix _ip to __ip name in magic example file.
 
 	* Changed 'tar -x -f' to 'tar xvf' in auto-installer. This should
 	work with non-gnu versions of tar.
 
 2001-11-06  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.2. Just to keep track of the recent changes.
 
 	* Fixed nasty bug in output prompt routine. It used to check 'if
 	arg != None...'. Problem is, this fails if arg implements a
 	special comparison (__cmp__) which disallows comparing to
 	None. Found it when trying to use the PhysicalQuantity module from
 	ScientificPython.
 
 2001-11-05  Fernando Perez  <[e-mail]>
 
 	* Also added dirs. Now the pushd/popd/dirs family functions
 	basically like the shell, with the added convenience of going home
 	when called with no args.
 
 	* pushd/popd slightly modified to mimic shell behavior more
 	closely.
 
 	* Added env,pushd,popd from ShellServices as magic functions. I
 	think the cleanest will be to port all desired functions from
 	ShellServices as magics and remove ShellServices altogether. This
 	will provide a single, clean way of adding functionality
 	(shell-type or otherwise) to IP.
 
 2001-11-04  Fernando Perez  <[e-mail]>
 
 	* Added .ipython/ directory to sys.path. This way users can keep
 	customizations there and access them via import.
 
 2001-11-03  Fernando Perez  <[e-mail]>
 
 	* Opened version 0.1.1 for new changes.
 
 	* Changed version number to 0.1.0: first 'public' release, sent to
 	Nathan and Janko.
 
 	* Lots of small fixes and tweaks.
 
 	* Minor changes to whos format. Now strings are shown, snipped if
 	too long.
 
 	* Changed ShellServices to work on __main__ so they show up in @who
 
 	* Help also works with ? at the end of a line:
 		?sin and sin?
 	both produce the same effect. This is nice, as often I use the
 	tab-complete to find the name of a method, but I used to then have
 	to go to the beginning of the line to put a ? if I wanted more
 	info. Now I can just add the ? and hit return. Convenient.
 
 2001-11-02  Fernando Perez  <[e-mail]>
 
 	* Python version check (>=2.1) added.
 
 	* Added LazyPython documentation. At this point the docs are quite
 	a mess. A cleanup is in order.
 
 	* Auto-installer created. For some bizarre reason, the zipfiles
 	module isn't working on my system. So I made a tar version
 	(hopefully the command line options in various systems won't kill
 	me).
 
 	* Fixes to Struct in genutils. Now all dictionary-like methods are
 	protected (reasonably).
 
 	* Added pager function to genutils and changed ? to print usage
 	note through it (it was too long).
 
 	* Added the LazyPython functionality. Works great! I changed the
 	auto-quote escape to ';', it's on home row and next to '. But
 	both auto-quote and auto-paren (still /) escapes are command-line
 	parameters.
 	
 
 2001-11-01  Fernando Perez  <[e-mail]>
 
 	* Version changed to 0.0.7. Fairly large change: configuration now
 	is all stored in a directory, by default .ipython. There, all
 	config files have normal looking names (not .names)
 
 	* Version 0.0.6 Released first to Lucas and Archie as a test
 	run. Since it's the first 'semi-public' release, change version to
 	> 0.0.6 for any changes now.
 
 	* Stuff I had put in the ipplib.py changelog:
 	
 	Changes to InteractiveShell:
 	
 	- Made the usage message a parameter.
 	
 	- Require the name of the shell variable to be given. It's a bit
 	of a hack, but allows the name 'shell' not to be hardwire in the
 	magic (@) handler, which is problematic b/c it requires
 	polluting the global namespace with 'shell'. This in turn is
 	fragile: if a user redefines a variable called shell, things
 	break.
 
 	- magic @: all functions available through @ need to be defined
 	as magic_<name>, even though they can be called simply as
 	@<name>. This allows the special command @magic to gather
 	information automatically about all existing magic functions,
 	even if they are run-time user extensions, by parsing the shell
 	instance __dict__ looking for special magic_ names.
 
 	- mainloop: added *two* local namespace parameters. This allows
 	the class to differentiate between parameters which were there
 	before and after command line initialization was processed. This
 	way, later @who can show things loaded at startup by the
 	user. This trick was necessary to make session saving/reloading
 	really work: ideally after saving/exiting/reloading a session,
 	*everythin* should look the same, including the output of @who. I
 	was only able to make this work with this double namespace
 	trick.
 
 	- added a header to the logfile which allows (almost) full
 	session restoring.
 
 	- prepend lines beginning with @ or !, with a and log
 	them. Why?  !lines: may be useful to know what you did @lines:
 	they may affect session state. So when restoring a session, at
 	least inform the user of their presence. I couldn't quite get
 	them to properly re-execute, but at least the user is warned.
 
 	* Started ChangeLog.

doc/ipython.1

@@ -1,395 +1,406 b''
 .\"                                      Hey, EMACS: -*- nroff -*-
 .\" First parameter, NAME, should be all caps
 .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 .\" other parameters are allowed: see man(7), man(1)
 .TH IPYTHON 1 "November 30, 2004"
 .\" Please adjust this date whenever revising the manpage.
 .\"
 .\" Some roff macros, for reference:
 .\" .nh        disable hyphenation
 .\" .hy        enable hyphenation
 .\" .ad l      left justify
 .\" .ad b      justify to both left and right margins
 .\" .nf        disable filling
 .\" .fi        enable filling
 .\" .br        insert line break
 .\" .sp <n>    insert n+1 empty lines
 .\" for manpage-specific macros, see man(7) and groff_man(7)
 .\" .SH        section heading
 .\" .SS        secondary section heading
 .\"
 .\"
 .\" To preview this page as plain text: nroff -man ipython.1
 .\"
 .SH NAME
 ipython \- An Enhanced Interactive Python
 .SH SYNOPSIS
 .B ipython
 .RI [ options ] " files" ...
 .SH DESCRIPTION
 An interactive Python shell with automatic history (input and output),
 dynamic object introspection, easier configuration, command
 completion, access to the system shell, integration with numerical and
 scientific computing tools, and more.
 .SH SPECIAL THREADING OPTIONS
 The following special options are ONLY valid at the beginning of the command
 line, and not later.  This is because they control the initialization of
 ipython itself, before the normal option-handling mechanism is active.
 .TP
 .B \-gthread, \-qthread, \-wthread, \-pylab
 Only ONE of these can be given, and it can only be given as the first option
 passed to IPython (it will have no effect in any other position).  They
 provide threading support for the GTK, QT and WXWidgets toolkits, and for the
 matplotlib library.
 .br
 .sp 1
 With any of the first three options, IPython starts running a separate thread
 for the graphical toolkit's operation, so that you can open and control
 graphical elements from within an IPython command line, without blocking.  All
 three provide essentially the same functionality, respectively for GTK, QT and
 WXWidgets (via their Python interfaces).
 .br
 .sp 1
+Note that with \-wthread, you can additionally use the \-wxversion option to
+request a specific version of wx to be used.  This requires that you have the
+'wxversion' Python module installed, which is part of recent wxPython
+distributions.
+.br
+.sp 1
 If \-pylab is given, IPython loads special support for the matplotlib library
 (http://matplotlib.sourceforge.net), allowing interactive usage of any of its
 backends as defined in the user's .matplotlibrc file.  It automatically
 activates GTK, QT or WX threading for IPyhton if the choice of matplotlib
 backend requires it.  It also modifies the %run command to correctly execute
 (without blocking) any matplotlib-based script which calls show() at the end.
 .TP
 .B \-tk
 The \-g/q/wthread options, and \-pylab (if matplotlib is configured to use
 GTK, QT or WX), will normally block Tk graphical interfaces.  This means that
 when GTK, QT or WX threading is active, any attempt to open a Tk GUI will
 result in a dead window, and possibly cause the Python interpreter to crash.
 An extra option, \-tk, is available to address this issue.  It can ONLY be
 given as a SECOND option after any of the above (\-gthread, \-qthread,
 \-wthread or \-pylab).
 .br
 .sp 1
 If \-tk is given, IPython will try to coordinate Tk threading with GTK, QT or
 WX.  This is however potentially unreliable, and you will have to test on your
 platform and Python configuration to determine whether it works for you.
 Debian users have reported success, apparently due to the fact that Debian
 builds all of Tcl, Tk, Tkinter and Python with pthreads support.  Under other
 Linux environments (such as Fedora Core 2), this option has caused random
 crashes and lockups of the Python interpreter.  Under other operating systems
 (Mac OSX and Windows), you'll need to try it to find out, since currently no
 user reports are available.
 .br
 .sp 1
 There is unfortunately no way for IPython to determine at runtime whether \-tk
 will work reliably or not, so you will need to do some experiments before
 relying on it for regular work.
 .
 .SS A WARNING ABOUT SIGNALS AND THREADS
 When any of the thread systems (GTK, QT or WX) are active, either directly or
 via \-pylab with a threaded backend, it is impossible to interrupt
 long-running Python code via Ctrl\-C.  IPython can not pass the
 KeyboardInterrupt exception (or the underlying SIGINT) across threads, so any
 long-running process started from IPython will run to completion, or will have
 to be killed via an external (OS-based) mechanism.
 .br
 .sp 1
 To the best of my knowledge, this limitation is imposed by the Python
 interpreter itself, and it comes from the difficulty of writing portable
 signal/threaded code.  If any user is an expert on this topic and can suggest
 a better solution, I would love to hear about it.  In the IPython sources,
 look at the Shell.py module, and in particular at the runcode() method.
 .
 .SH REGULAR OPTIONS
 After the above threading options have been given, regular options can follow
 in any order.  All options can be abbreviated to their shortest non-ambiguous
 form and are case-sensitive.  One or two dashes can be used.  Some options
 have an alternate short form, indicated after a |.
 .br
 .sp 1
 Most options can also be set from your ipythonrc configuration file.
 See the provided examples for assistance.  Options given on the
 commandline override the values set in the ipythonrc file.
 .br
 .sp 1
 All options with a [no] prepended can be specified in negated form
 (\-nooption instead of \-option) to turn the feature off.
 .TP
 .B \-h, \-\-help
 Show summary of options.
 .TP
 .B \-autocall <val>
 Make IPython automatically call any callable object even if you didn't type
 explicit parentheses. For example, 'str 43' becomes
 'str(43)' automatically.  The value can be '0' to disable the
 feature, '1' for 'smart' autocall, where it is not applied if
 there are no more arguments on the line, and '2' for 'full'
 autocall, where all callable objects are automatically called
 (even if no arguments are present).  The default is '1'.
 .TP
 .B \-[no]autoindent
 Turn automatic indentation on/off.
 .TP
 .B \-[no]automagic
 Make magic commands automatic (without needing their first character
 to be %).  Type %magic at the IPython prompt for more information.
 .TP
 .B \-[no]autoedit_syntax
 When a syntax error occurs after editing a file, automatically open the file
 to the trouble causing line for convenient fixing.
 .TP
 .B \-[no]banner
 Print the intial information banner (default on).
 .TP
 .B \-c <command>
 Execute the given command string, and set sys.argv to ['c'].  This is similar
 to the \-c option in the normal Python interpreter.
 .TP
 .B \-cache_size|cs <n>
 Size of the output cache (maximum number of entries to hold in
 memory).  The default is 1000, you can change it permanently in your
 config file.  Setting it to 0 completely disables the caching system,
 and the minimum value accepted is 20 (if you provide a value less than
 20, it is reset to 0 and a warning is issued).  This limit is defined
 because otherwise you'll spend more time re-flushing a too small cache
 than working.
 .TP
 .B \-classic|cl
 Gives IPython a similar feel to the classic Python prompt.
 .TP
 .B \-colors <scheme>
 Color scheme for prompts and exception reporting.  Currently
 implemented: NoColor, Linux, and LightBG.
 .TP
 .B \-[no]color_info
 IPython can display information about objects via a set of functions,
 and optionally can use colors for this, syntax highlighting source
 code and various other elements.  However, because this information is
 passed through a pager (like 'less') and many pagers get confused with
 color codes, this option is off by default.  You can test it and turn
 it on permanently in your ipythonrc file if it works for you.  As a
 reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
 that in RedHat 7.2 doesn't.
 .br
 .sp 1
 Test it and turn it on permanently if it works with your system.  The
 magic function @color_info allows you to toggle this interactively for
 testing.
 .TP
 .B \-[no]confirm_exit
 Set to confirm when you try to exit IPython with an EOF (Control-D in
 Unix, Control-Z/Enter in Windows). Note that using the magic functions
 @Exit or @Quit you can force a direct exit, bypassing any
 confirmation.
 .TP
 .B \-[no]debug
 Show information about the loading process. Very useful to pin down
 problems with your configuration files or to get details about session
 restores.
 .TP
 .B \-[no]deep_reload
 IPython can use the deep_reload module which reloads changes in
 modules recursively (it replaces the reload() function, so you don't
 need to change anything to use it). deep_reload() forces a full reload
 of modules whose code may have changed, which the default reload()
 function does not.
 .br
 .sp 1
 When deep_reload is off, IPython will use the normal reload(), but
 deep_reload will still be available as dreload(). This feature is off
 by default [which means that you have both normal reload() and
 dreload()].
 .TP
 .B \-editor <name>
 Which editor to use with the @edit command. By default, IPython will
 honor your EDITOR environment variable (if not set, vi is the Unix
 default and notepad the Windows one). Since this editor is invoked on
 the fly by IPython and is meant for editing small code snippets, you
 may want to use a small, lightweight editor here (in case your default
 EDITOR is something like Emacs).
 .TP
 .B \-ipythondir <name>
 The name of your IPython configuration directory IPYTHONDIR.  This can
 also be specified through the environment variable IPYTHONDIR.
 .TP
 .B \-log|l
 Generate a log file of all input. The file is named ipython_log.py in your
 current directory (which prevents logs from multiple IPython sessions from
 trampling each other). You can use this to later restore a session by loading
 your logfile as a file to be executed with option -logplay (see below).
 .TP
 .B \-logfile|lf
 Specify the name of your logfile.
 .TP
 .B \-logplay|lp
 Replay a previous log. For restoring a session as close as possible to
 the state you left it in, use this option (don't just run the
 logfile). With \-logplay, IPython will try to reconstruct the previous
 working environment in full, not just execute the commands in the
 logfile.
 .br
 .sh 1
 When a session is restored, logging is automatically turned on again
 with the name of the logfile it was invoked with (it is read from the
 log header). So once you've turned logging on for a session, you can
 quit IPython and reload it as many times as you want and it will
 continue to log its history and restore from the beginning every time.
 .br
 .sp 1
 Caveats: there are limitations in this option. The history variables
 _i*,_* and _dh don't get restored properly. In the future we will try
 to implement full session saving by writing and retrieving a
 'snapshot' of the memory state of IPython. But our first attempts
 failed because of inherent limitations of Python's Pickle module, so
 this may have to wait.
 .TP
 .B \-[no]messages
 Print messages which IPython collects about its startup process
 (default on).
 .TP
 .B \-[no]pdb
 Automatically call the pdb debugger after every uncaught exception. If
 you are used to debugging using pdb, this puts you automatically
 inside of it after any call (either in IPython or in code called by
 it) which triggers an exception which goes uncaught.
 .TP
 .B \-[no]pprint
 IPython can optionally use the pprint (pretty printer) module for
 displaying results. pprint tends to give a nicer display of nested
 data structures. If you like it, you can turn it on permanently in
 your config file (default off).
 .TP
 .B \-profile|p <name>
 Assume that your config file is ipythonrc-<name> (looks in current dir
 first, then in IPYTHONDIR). This is a quick way to keep and load
 multiple config files for different tasks, especially if you use the
 include option of config files. You can keep a basic
 IPYTHONDIR/ipythonrc file and then have other 'profiles' which include
 this one and load extra things for particular tasks. For example:
 .br
 .sp 1
 1) $HOME/.ipython/ipythonrc : load basic things you always want.
 .br
 2) $HOME/.ipython/ipythonrc-math : load (1) and basic math-related
 modules.
 .br
 3) $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and
 plotting modules.
 .br
 .sp 1
 Since it is possible to create an endless loop by having circular file
 inclusions, IPython will stop if it reaches 15 recursive inclusions.
 .TP
 .B \-prompt_in1|pi1 <string>
 Specify the string used for input prompts. Note that if you are using
 numbered prompts, the number is represented with a '\\#' in the
 string. Don't forget to quote strings with spaces embedded in
 them. Default: 'In [\\#]:'.
 .br
 .sp 1
 Most bash-like escapes can be used to customize IPython's prompts, as well as
 a few additional ones which are IPython-specific.  All valid prompt escapes
 are described in detail in the Customization section of the IPython HTML/PDF
 manual.
 .TP
 .B \-prompt_in2|pi2 <string>
 Similar to the previous option, but used for the continuation prompts. The
 special sequence '\\D' is similar to '\\#', but with all digits replaced dots
 (so you can have your continuation prompt aligned with your input
 prompt). Default: '   .\\D.:' (note three spaces at the start for alignment
 with 'In [\\#]').
 .TP
 .B \-prompt_out|po <string>
 String used for output prompts, also uses numbers like prompt_in1.
 Default: 'Out[\\#]:'.
 .TP
 .B \-quick
 Start in bare bones mode (no config file loaded).
 .TP
 .B \-rcfile <name>
 Name of your IPython resource configuration file.  normally IPython
 loads ipythonrc (from current directory) or IPYTHONDIR/ipythonrc.  If
 the loading of your config file fails, IPython starts with a bare
 bones configuration (no modules loaded at all).
 .TP
 .B \-[no]readline
 Use the readline library, which is needed to support name completion
 and command history, among other things. It is enabled by default, but
 may cause problems for users of X/Emacs in Python comint or shell
 buffers.
 .br
 .sp 1
 Note that emacs 'eterm' buffers (opened with M-x term) support
 IPython's readline and syntax coloring fine, only 'emacs' (M-x shell
 and C-c !)  buffers do not.
 .TP
 .B \-screen_length|sl <n>
 Number of lines of your screen.  This is used to control printing of
 very long strings.  Strings longer than this number of lines will be
 sent through a pager instead of directly printed.
 .br
 .sp 1
 The default value for this is 0, which means IPython will auto-detect
 your screen size every time it needs to print certain potentially long
 strings (this doesn't change the behavior of the 'print' keyword, it's
 only triggered internally). If for some reason this isn't working well
 (it needs curses support), specify it yourself. Otherwise don't change
 the default.
 .TP
 .B \-separate_in|si <string>
 Separator before input prompts.  Default '\n'.
 .TP
 .B \-separate_out|so <string>
 Separator before output prompts.  Default: 0 (nothing).
 .TP
 .B \-separate_out2|so2 <string>
 Separator after output prompts.  Default: 0 (nothing).
 .TP
 .B \-nosep
 Shorthand for '\-separate_in 0 \-separate_out 0 \-separate_out2 0'.
 Simply removes all input/output separators.
 .TP
 .B \-upgrade
 Allows you to upgrade your IPYTHONDIR configuration when you install a
 new version of IPython.  Since new versions may include new command
 lines options or example files, this copies updated ipythonrc-type
 files.  However, it backs up (with a .old extension) all files which
 it overwrites so that you can merge back any custimizations you might
 have in your personal files.
 .TP
 .B \-Version
 Print version information and exit.
 .TP
+.B -wxversion <string>
+Select a specific version of wxPython (used in conjunction with
+\-wthread). Requires the wxversion module, part of recent wxPython
+distributions.
+.TP
 .B \-xmode <modename>
 Mode for exception reporting.  The valid modes are Plain, Context, and
 Verbose.
 .br
 .sp 1
 \- Plain: similar to python's normal traceback printing.
 .br
 .sp 1
 \- Context: prints 5 lines of context source code around each line in the
 traceback.
 .br
 .sp 1
 \- Verbose: similar to Context, but additionally prints the variables
 currently visible where the exception happened (shortening their strings if
 too long).  This can potentially be very slow, if you happen to have a huge
 data structure whose string representation is complex to compute.  Your
 computer may appear to freeze for a while with cpu usage at 100%.  If this
 occurs, you can cancel the traceback with Ctrl-C (maybe hitting it more than
 once).
 .
 .SH EMBEDDING
 It is possible to start an IPython instance inside your own Python
 programs.  In the documentation example files there are some
 illustrations on how to do this.
 .br
 .sp 1
 This feature allows you to evalutate dynamically the state of your
 code, operate with your variables, analyze them, etc.  Note however
 that any changes you make to values while in the shell do NOT
 propagate back to the running code, so it is safe to modify your
 values because you won't break your code in bizarre ways by doing so.
 .SH AUTHOR
 IPython was written by Fernando Perez <[e-mail]>, based on earlier
 code by Janko Hauser <[e-mail]> and Nathaniel Gray
 <[e-mail]>.  This manual page was written by Jack Moffitt
 <[e-mail]>, for the Debian project (but may be used by others).

doc/manual_base.lyx

@@ -1,9173 +1,9259 b''
 #LyX 1.3 created this file. For more info see http://www.lyx.org/
 \lyxformat 221
 \textclass article
 \begin_preamble
 %\usepackage{ae,aecompl}
 \usepackage{color}
 
 % A few colors to replace the defaults for certain link types
 \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
 \definecolor{darkorange}{rgb}{.71,0.21,0.01}
 \definecolor{darkred}{rgb}{.52,0.08,0.01}
 \definecolor{darkgreen}{rgb}{.12,.54,.11}
 
 % Use and configure listings package for nicely formatted code
 \usepackage{listings}
 \lstset{
   language=Python,
   basicstyle=\small\ttfamily,
   commentstyle=\ttfamily\color{blue},
   stringstyle=\ttfamily\color{darkorange},
   showstringspaces=false,
   breaklines=true,
   postbreak = \space\dots
 }
 
 \usepackage[%pdftex,  % needed for pdflatex
   breaklinks=true,  % so long urls are correctly broken across lines
   colorlinks=true,
   urlcolor=blue,
   linkcolor=darkred,
   citecolor=darkgreen,
   ]{hyperref}
 
 \usepackage{html}
 
 % This helps prevent overly long lines that stretch beyond the margins
 \sloppy
 
 % Define a \codelist command which either uses listings for latex, or
 % plain verbatim for html (since latex2html doesn't understand the 
 % listings package).
 \usepackage{verbatim}
 \newcommand{\codelist}[1] {
 \latex{\lstinputlisting{#1}}
 \html{\verbatiminput{#1}}
 }
 \end_preamble
 \language english
 \inputencoding latin1
 \fontscheme palatino
 \graphics default
 \paperfontsize 10
 \spacing single 
 \papersize Default
 \paperpackage a4
 \use_geometry 1
 \use_amsmath 0
 \use_natbib 0
 \use_numerical_citations 0
 \paperorientation portrait
 \leftmargin 1.1in
 \topmargin 1in
 \rightmargin 1.1in
 \bottommargin 1in
 \secnumdepth 3
 \tocdepth 3
 \paragraph_separation skip
 \defskip medskip
 \quotes_language english
 \quotes_times 2
 \papercolumns 1
 \papersides 1
 \paperpagestyle fancy
 
 \layout Title
 
 IPython
 \newline 
 
 \size larger 
 An enhanced Interactive Python
 \size large 
 
 \newline 
 User Manual, v.
  __version__
 \layout Author
 
 Fernando P�rez
 \layout Standard
 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 latex{
 \end_inset 
 
 
 \begin_inset LatexCommand \tableofcontents{}
 
 \end_inset 
 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 }
 \end_inset 
 
 
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 html{
 \backslash 
 bodytext{bgcolor=#ffffff}}
 \end_inset 
 
 
 \layout Section
 \pagebreak_top 
 Overview
 \layout Standard
 
 One of Python's most useful features is its interactive interpreter.
  This system allows very fast testing of ideas without the overhead of creating
  test files as is typical in most programming languages.
  However, the interpreter supplied with the standard Python distribution
  is somewhat limited for extended interactive use.
 \layout Standard
 
 IPython is a free software project (released under the BSD license) which
  tries to:
 \layout Enumerate
 
 Provide an interactive shell superior to Python's default.
  IPython has many features for object introspection, system shell access,
  and its own special command system for adding functionality when working
  interactively.
  It tries to be a very efficient environment both for Python code development
  and for exploration of problems using Python objects (in situations like
  data analysis).
 \layout Enumerate
 
 Serve as an embeddable, ready to use interpreter for your own programs.
  IPython can be started with a single call from inside another program,
  providing access to the current namespace.
  This can be very useful both for debugging purposes and for situations
  where a blend of batch-processing and interactive exploration are needed.
 \layout Enumerate
 
 Offer a flexible framework which can be used as the base environment for
  other systems with Python as the underlying language.
  Specifically scientific environments like Mathematica, IDL and Matlab inspired
  its design, but similar ideas can be useful in many fields.
+\layout Enumerate
+
+Allow interactive testing of threaded graphical toolkits.
+ IPython has support for interactive, non-blocking control of GTK, Qt and
+ WX applications via special threading flags.
+ The normal Python shell can only do this for Tkinter applications.
 \layout Subsection
 
 Main features
 \layout Itemize
 
 Dynamic object introspection.
  One can access docstrings, function definition prototypes, source code,
  source files and other details of any object accessible to the interpreter
  with a single keystroke (`
 \family typewriter 
 ?
 \family default 
-').
+', and using `
+\family typewriter 
+??
+\family default 
+' provides additional detail).
+\layout Itemize
+
+Searching through modules and namespaces with `
+\family typewriter 
+*
+\family default 
+' wildcards, both when using the `
+\family typewriter 
+?
+\family default 
+' system and via the 
+\family typewriter 
+%psearch
+\family default 
+ command.
 \layout Itemize
 
 Completion in the local namespace, by typing TAB at the prompt.
  This works for keywords, methods, variables and files in the current directory.
  This is supported via the readline library, and full access to configuring
  readline's behavior is provided.
 \layout Itemize
 
 Numbered input/output prompts with command history (persistent across sessions
  and tied to each profile), full searching in this history and caching of
  all input and output.
 \layout Itemize
 
 User-extensible `magic' commands.
  A set of commands prefixed with 
 \family typewriter 
 %
 \family default 
  is available for controlling IPython itself and provides directory control,
  namespace information and many aliases to common system shell commands.
 \layout Itemize
 
 Alias facility for defining your own system aliases.
 \layout Itemize
 
 Complete system shell access.
  Lines starting with ! are passed directly to the system shell, and using
  !! captures shell output into python variables for further use.
 \layout Itemize
 
-All calls to the system (via aliases or via !) have their standard output/error
- automatically stored as strings, and also available as lists.
-\layout Itemize
-
 Background execution of Python commands in a separate thread.
  IPython has an internal job manager called 
 \family typewriter 
 jobs
 \family default 
 , and a conveninence backgrounding magic function called 
 \family typewriter 
 %bg
 \family default 
 .
 \layout Itemize
 
 The ability to expand python variables when calling the system shell.
  In a shell command, any python variable prefixed with 
 \family typewriter 
 $
 \family default 
  is expanded.
  A double 
 \family typewriter 
 $$
 \family default 
  allows passing a literal 
 \family typewriter 
 $
 \family default 
  to the shell (for access to shell and environment variables like 
 \family typewriter 
 $PATH
 \family default 
 ).
 \layout Itemize
 
 Filesystem navigation, via a magic 
 \family typewriter 
 %cd
 \family default 
  command, along with a persistent bookmark system (using 
 \family typewriter 
 %bookmark
 \family default 
 ) for fast access to frequently visited directories.
 \layout Itemize
 
+A lightweight persistence framework via the 
+\family typewriter 
+%store
+\family default 
+ command, which allows you to save arbitrary Python variables.
+ These get restored automatically when your session restarts.
+\layout Itemize
+
 Automatic indentation (optional) of code as you type (through the readline
  library).
 \layout Itemize
 
 Macro system for quickly re-executing multiple lines of previous input with
  a single name.
+ Macros can be stored persistently via 
+\family typewriter 
+%store
+\family default 
+ and edited via 
+\family typewriter 
+%edit
+\family default 
+.
+ 
 \layout Itemize
 
 Session logging (you can then later use these logs as code in your programs).
+ Logs can optionally timestamp all input, and also store session output
+ (marked as comments, so the log remains valid Python source code).
 \layout Itemize
 
 Session restoring: logs can be replayed to restore a previous session to
  the state where you left it.
 \layout Itemize
 
 Verbose and colored exception traceback printouts.
  Easier to parse visually, and in verbose mode they produce a lot of useful
  debugging information (basically a terminal version of the cgitb module).
 \layout Itemize
 
 Auto-parentheses: callable objects can be executed without parentheses:
  
 \family typewriter 
 `sin 3'
 \family default 
  is automatically converted to 
 \family typewriter 
 `sin(3)
 \family default 
 '.
 \layout Itemize
 
 Auto-quoting: using `
 \family typewriter 
 ,
 \family default 
 ' or `
 \family typewriter 
 ;
 \family default 
 ' as the first character forces auto-quoting of the rest of the line: 
 \family typewriter 
 `,my_function a\SpecialChar ~
 b'
 \family default 
  becomes automatically 
 \family typewriter 
 `my_function("a","b")'
 \family default 
 , while 
 \family typewriter 
 `;my_function a\SpecialChar ~
 b'
 \family default 
  becomes 
 \family typewriter 
 `my_function("a b")'
 \family default 
 .
 \layout Itemize
 
 Extensible input syntax.
  You can define filters that pre-process user input to simplify input in
  special situations.
  This allows for example pasting multi-line code fragments which start with
  
 \family typewriter 
 `>>>'
 \family default 
  or 
 \family typewriter 
 `...'
 \family default 
  such as those from other python sessions or the standard Python documentation.
 \layout Itemize
 
 Flexible configuration system.
  It uses a configuration file which allows permanent setting of all command-line
  options, module loading, code and file execution.
  The system allows recursive file inclusion, so you can have a base file
  with defaults and layers which load other customizations for particular
  projects.
 \layout Itemize
 
 Embeddable.
  You can call IPython as a python shell inside your own python programs.
  This can be used both for debugging code or for providing interactive abilities
  to your programs with knowledge about the local namespaces (very useful
  in debugging and data analysis situations).
 \layout Itemize
 
 Easy debugger access.
  You can set IPython to call up an enhanced version of the Python debugger
  (
 \family typewriter 
 pdb
 \family default 
 ) every time there is an uncaught exception.
  This drops you inside the code which triggered the exception with all the
  data live and it is possible to navigate the stack to rapidly isolate the
  source of a bug.
  The 
 \family typewriter 
 %run
 \family default 
  magic command --with the 
 \family typewriter 
 -d
 \family default 
  option-- can run any script under 
 \family typewriter 
 pdb
 \family default 
 's control, automatically setting initial breakpoints for you.
  This version of 
 \family typewriter 
 pdb
 \family default 
  has IPython-specific improvements, including tab-completion and traceback
  coloring support.
 \layout Itemize
 
 Profiler support.
  You can run single statements (similar to 
 \family typewriter 
 profile.run()
 \family default 
 ) or complete programs under the profiler's control.
  While this is possible with the standard 
 \family typewriter 
 profile
 \family default 
  module, IPython wraps this functionality with magic commands (see 
 \family typewriter 
 `%prun'
 \family default 
  and 
 \family typewriter 
 `%run -p
 \family default 
 ') convenient for rapid interactive work.
 \layout Subsection
 
 Portability and Python requirements
 \layout Standard
 
 
 \series bold 
 Python requirements: 
 \series default 
-IPython works with Python version 2.2 or newer.
- It has been tested with Python 2.4 and no problems have been reported.
- Support for Python 2.1 hasn't been recently tested, since I don't have access
- to it on any of my systems.
- But I suspect there may be some problems with Python 2.1, because some of
- the newer code may use 2.2 features.
+IPython requires with Python version 2.3 or newer.
+ If you are still using Python 2.2 and can not upgrade, the last version
+ of IPython which worked with Python 2.2 was 0.6.15, so you will have to use
+ that.
 \layout Standard
 
 IPython is developed under 
 \series bold 
 Linux
 \series default 
 , but it should work in any reasonable Unix-type system (tested OK under
  Solaris and the *BSD family, for which a port exists thanks to Dryice Liu).
 \layout Standard
 
 
 \series bold 
 Mac OS X
 \series default 
 : it works, apparently without any problems (thanks to Jim Boyle at Lawrence
  Livermore for the information).
  Thanks to Andrea Riciputi, Fink support is available.
 \layout Standard
 
 
 \series bold 
 CygWin
 \series default 
 : it works mostly OK, though some users have reported problems with prompt
  coloring.
  No satisfactory solution to this has been found so far, you may want to
  disable colors permanently in the 
 \family typewriter 
 ipythonrc
 \family default 
  configuration file if you experience problems.
  If you have proper color support under cygwin, please post to the IPython
  mailing list so this issue can be resolved for all users.
 \layout Standard
 
 
 \series bold 
 Windows
 \series default 
 : it works well under Windows XP/2k, and I suspect NT should behave similarly.
  Section\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sub:Under-Windows}
 
 \end_inset 
 
  describes installation details for Windows, including some additional tools
  needed on this platform.
 \layout Standard
 
 Windows 9x support is present, and has been reported to work fine (at least
  on WinME).
 \layout Standard
 
-Please note, however, that I have very little access to and experience with
- Windows development.
- For this reason, Windows-specific bugs tend to linger far longer than I
- would like, and often I just can't find a satisfactory solution.
- If any Windows user wants to join in with development help, all hands are
- always welcome.
+Note, that I have very little access to and experience with Windows development.
+ However, an excellent group of Win32 users (led by Ville Vainio), consistenly
+ contribute bugfixes and platform-specific enhancements, so they more than
+ make up for my deficiencies on that front.
+ In fact, Win32 users report using IPython as a system shell (see Sec.\SpecialChar ~
+
+\begin_inset LatexCommand \ref{sec:IPython-as-shell}
+
+\end_inset 
+
+ for details), as it offers a level of control and features which the default
+ 
+\family typewriter 
+cmd.exe
+\family default 
+ doesn't provide.
 \layout Subsection
 
 Location
 \layout Standard
 
 IPython is generously hosted at 
 \begin_inset LatexCommand \htmlurl{http://ipython.scipy.org}
 
 \end_inset 
 
- by the SciPy project.
+ by the Enthought, Inc and the SciPy project.
  This site offers downloads, subversion access, mailing lists and a bug
  tracking system.
  I am very grateful to Enthought (
 \begin_inset LatexCommand \htmlurl{http://www.enthought.com}
 
 \end_inset 
 
 ) and all of the SciPy team for their contribution.
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:install}
 
 \end_inset 
 
 Installation
 \layout Subsection
 
 Instant instructions
 \layout Standard
 
 If you are of the impatient kind, under Linux/Unix simply untar/unzip the
  download, then install with 
 \family typewriter 
 `python setup.py install'
 \family default 
 .
  Under Windows, double-click on the provided 
 \family typewriter 
 .exe
 \family default 
  binary installer.
 \layout Standard
 
 Then, take a look at Sections 
 \begin_inset LatexCommand \ref{sec:good_config}
 
 \end_inset 
 
  for configuring things optimally and 
 \begin_inset LatexCommand \ref{sec:quick_tips}
 
 \end_inset 
 
  for quick tips on efficient use of IPython.
  You can later refer to the rest of the manual for all the gory details.
 \layout Standard
 
 See the notes in sec.
  
 \begin_inset LatexCommand \ref{sec:upgrade}
 
 \end_inset 
 
  for upgrading IPython versions.
 \layout Subsection
 
 Detailed Unix instructions (Linux, Mac OS X, etc.)
 \layout Standard
 
 For RPM based systems, simply install the supplied package in the usual
  manner.
  If you download the tar archive, the process is:
 \layout Enumerate
 
 Unzip/untar the 
 \family typewriter 
 ipython-XXX.tar.gz
 \family default 
  file wherever you want (
 \family typewriter 
 XXX
 \family default 
  is the version number).
  It will make a directory called 
 \family typewriter 
 ipython-XXX.
  
 \family default 
 Change into that directory where you will find the files 
 \family typewriter 
 README
 \family default 
  and 
 \family typewriter 
 setup.py
 \family default 
 .
 
 \family typewriter 
  O
 \family default 
 nce you've completed the installation, you can safely remove this directory.
  
 \layout Enumerate
 
 If you are installing over a previous installation of version 0.2.0 or earlier,
  first remove your 
 \family typewriter 
 $HOME/.ipython
 \family default 
  directory, since the configuration file format has changed somewhat (the
  '=' were removed from all option specifications).
  Or you can call ipython with the 
 \family typewriter 
 -upgrade
 \family default 
  option and it will do this automatically for you.
 \layout Enumerate
 
 IPython uses distutils, so you can install it by simply typing at the system
  prompt (don't type the 
 \family typewriter 
 $
 \family default 
 )
 \newline 
 
 \family typewriter 
 $ python setup.py install
 \family default 
 
 \newline 
 Note that this assumes you have root access to your machine.
  If you don't have root access or don't want IPython to go in the default
  python directories, you'll need to use the 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|--home|
 \end_inset 
 
  option (or 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|--prefix|
 \end_inset 
 
 ).
  For example:
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|$ python setup.py install --home $HOME/local|
 \end_inset 
 
 
 \newline 
 will install IPython into 
 \family typewriter 
 $HOME/local 
 \family default 
 and its subdirectories (creating them if necessary).
 \newline 
 You can type
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|$ python setup.py --help|
 \end_inset 
 
  
 \newline 
 for more details.
 \newline 
 Note that if you change the default location for 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|--home|
 \end_inset 
 
  at installation, IPython may end up installed at a location which is not
  part of your 
 \family typewriter 
 $PYTHONPATH
 \family default 
  environment variable.
  In this case, you'll need to configure this variable to include the actual
  directory where the 
 \family typewriter 
 IPython/
 \family default 
  directory ended (typically the value you give to 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|--home|
 \end_inset 
 
  plus 
 \family typewriter 
 /lib/python
 \family default 
 ).
 \layout Subsubsection
 
 Mac OSX information
 \layout Standard
 
 Under OSX, there is a choice you need to make.
  Apple ships its own build of Python, which lives in the core OSX filesystem
  hierarchy.
  You can also manually install a separate Python, either purely by hand
  (typically in 
 \family typewriter 
 /usr/local
 \family default 
 ) or by using Fink, which puts everything under 
 \family typewriter 
 /sw
 \family default 
 .
  Which route to follow is a matter of personal preference, as I've seen
  users who favor each of the approaches.
  Here I will simply list the known installation issues under OSX, along
  with their solutions.
 \layout Standard
 
 This page: 
 \begin_inset LatexCommand \htmlurl{http://geosci.uchicago.edu/~tobis/pylab.html}
 
 \end_inset 
 
  contains information on this topic, with additional details on how to make
  IPython and matplotlib play nicely under OSX.
 \layout Subsubsection*
 
 GUI problems
 \layout Standard
 
 The following instructions apply to an install of IPython under OSX from
  unpacking the 
 \family typewriter 
 .tar.gz
 \family default 
  distribution and installing it for the default Python interpreter shipped
  by Apple.
  If you are using a fink install, fink will take care of these details for
  you, by installing IPython against fink's Python.
 \layout Standard
 
 IPython offers various forms of support for interacting with graphical applicati
 ons from the command line, from simple Tk apps (which are in principle always
  supported by Python) to interactive control of WX, Qt and GTK apps.
  Under OSX, however, this requires that ipython is installed by calling
  the special 
 \family typewriter 
 pythonw
 \family default 
  script at installation time, which takes care of coordinating things with
  Apple's graphical environment.
 \layout Standard
 
 So when installing under OSX, it is best to use the following command:
 \family typewriter 
 
 \newline 
 
 \family default 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|  $ sudo pythonw setup.py install --install-scripts=/usr/local/bin|
 \end_inset 
 
 
 \newline 
  or
 \newline 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 verb|  $ sudo pythonw setup.py install --install-scripts=/usr/bin|
 \end_inset 
 
 
 \newline 
 depending on where you like to keep hand-installed executables.
 \layout Standard
 
 The resulting script will have an appropriate shebang line (the first line
  in the script whic begins with 
 \family typewriter 
 #!...
 \family default 
 ) such that the ipython interpreter can interact with the OS X GUI.
  If the installed version does not work and has a shebang line that points
  to, for example, just 
 \family typewriter 
 /usr/bin/python
 \family default 
 , then you might have a stale, cached version in your 
 \family typewriter 
 build/scripts-<python-version>
 \family default 
  directory.
  Delete that directory and rerun the 
 \family typewriter 
 setup.py
 \family default 
 .
  
 \layout Standard
 
 It is also a good idea to use the special flag 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 verb|--install-scripts|
 \end_inset 
 
  as indicated above, to ensure that the ipython scripts end up in a location
  which is part of your 
 \family typewriter 
 $PATH
 \family default 
 .
  Otherwise Apple's Python will put the scripts in an internal directory
  not available by default at the command line (if you use 
 \family typewriter 
 /usr/local/bin
 \family default 
 , you need to make sure this is in your 
 \family typewriter 
 $PATH
 \family default 
 , which may not be true by default).
 \layout Subsubsection*
 
 Readline problems
 \layout Standard
 
 By default, the Python version shipped by Apple does 
 \emph on 
 not
 \emph default 
  include the readline library, so central to IPython's behavior.
  If you install IPython against Apple's Python, you will not have arrow
  keys, tab completion, etc.
  For Mac OSX 10.3 (Panther), you can find a prebuilt readline library here:
 \newline 
 
 \begin_inset LatexCommand \htmlurl{http://pythonmac.org/packages/readline-5.0-py2.3-macosx10.3.zip}
 
 \end_inset 
 
  
 \layout Standard
 
 If you are using OSX 10.4 (Tiger), after installing this package you need
  to either: 
 \layout Enumerate
 
 move 
 \family typewriter 
 readline.so
 \family default 
  from 
 \family typewriter 
 /Library/Python/2.3
 \family default 
  to 
 \family typewriter 
 /Library/Python/2.3/site-packages
 \family default 
 , or
 \layout Enumerate
 
 install 
 \begin_inset LatexCommand \htmlurl{http://pythonmac.org/packages/TigerPython23Compat.pkg.zip}
 
 \end_inset 
 
 
 \layout Standard
 
 Users installing against Fink's Python or a properly hand-built one should
  not have this problem.
 \layout Subsubsection*
 
 DarwinPorts
 \layout Standard
 
 I report here a message from an OSX user, who suggests an alternative means
  of using IPython under this operating system with good results.
  Please let me know of any updates that may be useful for this section.
  His message is reproduced verbatim below:
 \layout Quote
 
 From: Markus Banfi 
 \family typewriter 
 <markus.banfi-AT-mospheira.net>
 \layout Quote
 
 As a MacOS X (10.4.2) user I prefer to install software using DawinPorts instead
  of Fink.
  I had no problems installing ipython with DarwinPorts.
  It's just:
 \layout Quote
 
 
 \family typewriter 
 sudo port install py-ipython
 \layout Quote
 
 It automatically resolved all dependencies (python24, readline, py-readline).
  So far I did not encounter any problems with the DarwinPorts port of ipython.
  
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sub:Under-Windows}
 
 \end_inset 
 
 Windows instructions
 \layout Standard
 
 Some of IPython's very useful features are:
 \layout Itemize
 
 Integrated readline support (Tab-based file, object and attribute completion,
  input history across sessions, editable command line, etc.)
 \layout Itemize
 
 Coloring of prompts, code and tracebacks.
 \layout Standard
 
 These, by default, are only available under Unix-like operating systems.
  However, thanks to Gary Bishop's work, Windows XP/2k users can also benefit
  from them.
  His readline library implements both GNU readline functionality and color
  support, so that IPython under Windows XP/2k can be as friendly and powerful
  as under Unix-like environments.
 \layout Standard
 
 The
 \family typewriter 
  readline
 \family default 
  extension needs two other libraries to work, so in all you need:
 \layout Enumerate
 
 
 \family typewriter 
 PyWin32
 \family default 
  from 
 \begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/mhammond}
 
 \end_inset 
 
 .
 \layout Enumerate
 
 
 \family typewriter 
 CTypes
 \family default 
  from 
 \begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/theller/ctypes}
 
 \end_inset 
 
  (you 
 \emph on 
 must
 \emph default 
  use version 0.9.1 or newer).
 \layout Enumerate
 
 
 \family typewriter 
 Readline
 \family default 
  for Windows from 
 \begin_inset LatexCommand \htmlurl{http://sourceforge.net/projects/uncpythontools}
 
 \end_inset 
 
 .
 \layout Standard
 
 
 \series bold 
 Warning about a broken readline-like library:
 \series default 
  several users have reported problems stemming from using the pseudo-readline
  library at 
 \begin_inset LatexCommand \htmlurl{http://newcenturycomputers.net/projects/readline.html}
 
 \end_inset 
 
 .
  This is a broken library which, while called readline, only implements
  an incomplete subset of the readline API.
  Since it is still called readline, it fools IPython's detection mechanisms
  and causes unpredictable crashes later.
  If you wish to use IPython under Windows, you must NOT use this library,
  which for all purposes is (at least as of version 1.6) terminally broken.
 \layout Subsubsection
 
 Installation procedure
 \layout Standard
 
 Once you have the above installed, from the IPython download directory grab
  the 
 \family typewriter 
 ipython-XXX.win32.exe
 \family default 
  file, where 
 \family typewriter 
 XXX
 \family default 
  represents the version number.
  This is a regular windows executable installer, which you can simply double-cli
 ck to install.
  It will add an entry for IPython to your Start Menu, as well as registering
  IPython in the Windows list of applications, so you can later uninstall
  it from the Control Panel.
  
 \layout Standard
 
 IPython tries to install the configuration information in a directory named
  
 \family typewriter 
 .ipython
 \family default 
  (
 \family typewriter 
 _ipython
 \family default 
  under Windows) located in your `home' directory.
  IPython sets this directory by looking for a 
 \family typewriter 
 HOME
 \family default 
  environment variable; if such a variable does not exist, it uses 
 \family typewriter 
 HOMEDRIVE
 \backslash 
 HOMEPATH 
 \family default 
 (these are always defined by Windows).
  This typically gives something like 
 \family typewriter 
 C:
 \backslash 
 Documents and Settings
 \backslash 
 YourUserName
 \family default 
 , but your local details may vary.
  In this directory you will find all the files that configure IPython's
  defaults, and you can put there your profiles and extensions.
  This directory is automatically added by IPython to 
 \family typewriter 
 sys.path
 \family default 
 , so anything you place there can be found by 
 \family typewriter 
 import
 \family default 
  statements.
 \layout Paragraph
 
 Upgrading
 \layout Standard
 
 For an IPython upgrade, you should first uninstall the previous version.
  This will ensure that all files and directories (such as the documentation)
  which carry embedded version strings in their names are properly removed.
 \layout Paragraph
 
 Manual installation under Win32
 \layout Standard
 
 In case the automatic installer does not work for some reason, you can download
  the 
 \family typewriter 
 ipython-XXX.tar.gz
 \family default 
  file, which contains the full IPython source distribution (the popular
  WinZip can read 
 \family typewriter 
 .tar.gz
 \family default 
  files).
  After uncompressing the archive, you can install it at a command terminal
  just like any other Python module, by using 
 \family typewriter 
 `python setup.py install'
 \family default 
 .
  
 \layout Standard
 
 After the installation, run the supplied 
 \family typewriter 
 win32_manual_post_install.py 
 \family default 
 script, which creates the necessary Start Menu shortcuts for you.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:upgrade}
 
 \end_inset 
 
 Upgrading from a previous version
 \layout Standard
 
 If you are upgrading from a previous version of IPython, after doing the
  routine installation described above, you should call IPython with the
  
 \family typewriter 
 -upgrade
 \family default 
  option the first time you run your new copy.
  This will automatically update your configuration directory while preserving
  copies of your old files.
  You can then later merge back any personal customizations you may have
  made into the new files.
  It is a good idea to do this as there may be new options available in the
  new configuration files which you will not have.
 \layout Standard
 
 Under Windows, if you don't know how to call python scripts with arguments
  from a command line, simply delete the old config directory and IPython
  will make a new one.
  Win2k and WinXP users will find it in 
 \family typewriter 
 C:
 \backslash 
 Documents and Settings
 \backslash 
 YourUserName
 \backslash 
 _ipython
 \family default 
 , and Win 9x users under 
 \family typewriter 
 C:
 \backslash 
 Program Files
 \backslash 
 IPython
 \backslash 
 _ipython.
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:good_config}
 
 \end_inset 
 
 
 \begin_inset OptArg
 collapsed true
 
 \layout Standard
 
 Initial configuration
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 ldots
 \end_inset 
 
 
 \end_inset 
 
 Initial configuration of your environment
 \layout Standard
 
 This section will help you set various things in your environment for your
  IPython sessions to be as efficient as possible.
  All of IPython's configuration information, along with several example
  files, is stored in a directory named by default 
 \family typewriter 
 $HOME/.ipython
 \family default 
 .
  You can change this by defining the environment variable 
 \family typewriter 
 IPYTHONDIR
 \family default 
 , or at runtime with the command line option 
 \family typewriter 
 -ipythondir
 \family default 
 .
 \layout Standard
 
 If all goes well, the first time you run IPython it should automatically
  create a user copy of the config directory for you, based on its builtin
  defaults.
  You can look at the files it creates to learn more about configuring the
  system.
  The main file you will modify to configure IPython's behavior is called
  
 \family typewriter 
 ipythonrc
 \family default 
  (with a 
 \family typewriter 
 .ini
 \family default 
  extension under Windows), included for reference in Sec.
  
 \begin_inset LatexCommand \ref{sec:ipytonrc-sample}
 
 \end_inset 
 
 .
  This file is very commented and has many variables you can change to suit
  your taste, you can find more details in Sec.
  
 \begin_inset LatexCommand \ref{sec:customization}
 
 \end_inset 
 
 .
  Here we discuss the basic things you will want to make sure things are
  working properly from the beginning.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:help-access}
 
 \end_inset 
 
 Access to the Python help system
 \layout Standard
 
 This is true for Python in general (not just for IPython): you should have
  an environment variable called 
 \family typewriter 
 PYTHONDOCS
 \family default 
  pointing to the directory where your HTML Python documentation lives.
  In my system it's 
 \family typewriter 
 /usr/share/doc/python-docs-2.3.4/html
 \family default 
 , check your local details or ask your systems administrator.
  
 \layout Standard
 
 This is the directory which holds the HTML version of the Python manuals.
  Unfortunately it seems that different Linux distributions package these
  files differently, so you may have to look around a bit.
  Below I show the contents of this directory on my system for reference:
 \layout Standard
 
 
 \family typewriter 
 [html]> ls
 \newline 
 about.dat acks.html dist/ ext/ index.html lib/ modindex.html stdabout.dat tut/
  about.html api/ doc/ icons/ inst/ mac/ ref/ style.css
 \layout Standard
 
 You should really make sure this variable is correctly set so that Python's
  pydoc-based help system works.
  It is a powerful and convenient system with full access to the Python manuals
  and all modules accessible to you.
 \layout Standard
 
 Under Windows it seems that pydoc finds the documentation automatically,
  so no extra setup appears necessary.
 \layout Subsection
 
 Editor
 \layout Standard
 
 The 
 \family typewriter 
 %edit
 \family default 
  command (and its alias 
 \family typewriter 
 %ed
 \family default 
 ) will invoke the editor set in your environment as 
 \family typewriter 
 EDITOR
 \family default 
 .
  If this variable is not set, it will default to 
 \family typewriter 
 vi
 \family default 
  under Linux/Unix and to 
 \family typewriter 
 notepad
 \family default 
  under Windows.
  You may want to set this variable properly and to a lightweight editor
  which doesn't take too long to start (that is, something other than a new
  instance of 
 \family typewriter 
 Emacs
 \family default 
 ).
  This way you can edit multi-line code quickly and with the power of a real
  editor right inside IPython.
  
 \layout Standard
 
 If you are a dedicated 
 \family typewriter 
 Emacs
 \family default 
  user, you should set up the 
 \family typewriter 
 Emacs
 \family default 
  server so that new requests are handled by the original process.
  This means that almost no time is spent in handling the request (assuming
  an 
 \family typewriter 
 Emacs
 \family default 
  process is already running).
  For this to work, you need to set your 
 \family typewriter 
 EDITOR 
 \family default 
 environment variable to 
 \family typewriter 
 'emacsclient'
 \family default 
 .
 
 \family typewriter 
  
 \family default 
 The code below, supplied by Francois Pinard, can then be used in your 
 \family typewriter 
 .emacs
 \family default 
  file to enable the server:
 \layout Standard
 
 
 \family typewriter 
 (defvar server-buffer-clients)
 \newline 
 (when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm))
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 (server-start)
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 (defun fp-kill-server-with-buffer-routine ()
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 (and server-buffer-clients (server-done)))
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine))
 \layout Standard
 
 You can also set the value of this editor via the commmand-line option '-
 \family typewriter 
 editor'
 \family default 
  or in your 
 \family typewriter 
 ipythonrc
 \family default 
  file.
  This is useful if you wish to use specifically for IPython an editor different
  from your typical default (and for Windows users who tend to use fewer
  environment variables).
 \layout Subsection
 
 Color 
 \layout Standard
 
 The default IPython configuration has most bells and whistles turned on
  (they're pretty safe).
  But there's one that 
 \emph on 
 may
 \emph default 
  cause problems on some systems: the use of color on screen for displaying
  information.
  This is very useful, since IPython can show prompts and exception tracebacks
  with various colors, display syntax-highlighted source code, and in general
  make it easier to visually parse information.
 \layout Standard
 
 The following terminals seem to handle the color sequences fine:
 \layout Itemize
 
 Linux main text console, KDE Konsole, Gnome Terminal, E-term, rxvt, xterm.
 \layout Itemize
 
 CDE terminal (tested under Solaris).
  This one boldfaces light colors.
 \layout Itemize
 
 (X)Emacs buffers.
  See sec.
 \begin_inset LatexCommand \ref{sec:emacs}
 
 \end_inset 
 
  for more details on using IPython with (X)Emacs.
 \layout Itemize
 
 A Windows (XP/2k) command prompt 
 \emph on 
 with Gary Bishop's support extensions
 \emph default 
 .
  Gary's extensions are discussed in Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sub:Under-Windows}
 
 \end_inset 
 
 .
 \layout Itemize
 
 A Windows (XP/2k) CygWin shell.
  Although some users have reported problems; it is not clear whether there
  is an issue for everyone or only under specific configurations.
  If you have full color support under cygwin, please post to the IPython
  mailing list so this issue can be resolved for all users.
 \layout Standard
 
 These have shown problems:
 \layout Itemize
 
 Windows command prompt in WinXP/2k logged into a Linux machine via telnet
  or ssh.
 \layout Itemize
 
 Windows native command prompt in WinXP/2k, 
 \emph on 
 without 
 \emph default 
 Gary Bishop's extensions.
  Once Gary's readline library is installed, the normal WinXP/2k command
  prompt works perfectly.
 \layout Standard
 
 Currently the following color schemes are available:
 \layout Itemize
 
 
 \family typewriter 
 NoColor
 \family default 
 : uses no color escapes at all (all escapes are empty 
 \begin_inset Quotes eld
 \end_inset 
 
  
 \begin_inset Quotes eld
 \end_inset 
 
  strings).
  This 'scheme' is thus fully safe to use in any terminal.
 \layout Itemize
 
 
 \family typewriter 
 Linux
 \family default 
 : works well in Linux console type environments: dark background with light
  fonts.
  It uses bright colors for information, so it is difficult to read if you
  have a light colored background.
 \layout Itemize
 
 
 \family typewriter 
 LightBG
 \family default 
 : the basic colors are similar to those in the 
 \family typewriter 
 Linux
 \family default 
  scheme but darker.
  It is easy to read in terminals with light backgrounds.
 \layout Standard
 
 IPython uses colors for two main groups of things: prompts and tracebacks
  which are directly printed to the terminal, and the object introspection
  system which passes large sets of data through a pager.
 \layout Subsubsection
 
 Input/Output prompts and exception tracebacks
 \layout Standard
 
 You can test whether the colored prompts and tracebacks work on your system
  interactively by typing 
 \family typewriter 
 '%colors Linux'
 \family default 
  at the prompt (use '
 \family typewriter 
 %colors LightBG'
 \family default 
  if your terminal has a light background).
  If the input prompt shows garbage like:
 \newline 
 
 \family typewriter 
 [0;32mIn [[1;32m1[0;32m]: [0;00m
 \family default 
 
 \newline 
 instead of (in color) something like:
 \newline 
 
 \family typewriter 
 In [1]:
 \family default 
  
 \newline 
 this means that your terminal doesn't properly handle color escape sequences.
  You can go to a 'no color' mode by typing '
 \family typewriter 
 %colors NoColor
 \family default 
 '.
  
 \layout Standard
 
 You can try using a different terminal emulator program.
  To permanently set your color preferences, edit the file
 \family typewriter 
  $HOME/.ipython/ipythonrc 
 \family default 
 and set the 
 \family typewriter 
 colors
 \family default 
  option to the desired value.
 \layout Subsubsection
 
 Object details (types, docstrings, source code, etc.)
 \layout Standard
 
 IPython has a set of special functions for studying the objects you are
  working with, discussed in detail in Sec.
  
 \begin_inset LatexCommand \ref{sec:dyn-object-info}
 
 \end_inset 
 
 .
  But this system relies on passing information which is longer than your
  screen through a data pager, such as the common Unix 
 \family typewriter 
 less
 \family default 
  and 
 \family typewriter 
 more
 \family default 
  programs.
  In order to be able to see this information in color, your pager needs
  to be properly configured.
  I strongly recommend using 
 \family typewriter 
 less
 \family default 
  instead of 
 \family typewriter 
 more
 \family default 
 , as it seems that 
 \family typewriter 
 more
 \family default 
  simply can not understand colored text correctly.
 \layout Standard
 
 In order to configure 
 \family typewriter 
 less
 \family default 
  as your default pager, do the following:
 \layout Enumerate
 
 Set the environment 
 \family typewriter 
 PAGER
 \family default 
  variable to 
 \family typewriter 
 less
 \family default 
 .
 \layout Enumerate
 
 Set the environment 
 \family typewriter 
 LESS
 \family default 
  variable to 
 \family typewriter 
 -r
 \family default 
  (plus any other options you always want to pass to 
 \family typewriter 
 less
 \family default 
  by default).
  This tells 
 \family typewriter 
 less
 \family default 
  to properly interpret control sequences, which is how color information
  is given to your terminal.
 \layout Standard
 
 For the 
 \family typewriter 
 csh
 \family default 
  or 
 \family typewriter 
 tcsh
 \family default 
  shells, add to your 
 \family typewriter 
 ~/.cshrc
 \family default 
  file the lines:
 \layout Standard
 
 
 \family typewriter 
 setenv PAGER less
 \newline 
 setenv LESS -r
 \layout Standard
 
 There is similar syntax for other Unix shells, look at your system documentation
  for details.
 \layout Standard
 
 If you are on a system which lacks proper data pagers (such as Windows),
  IPython will use a very limited builtin pager.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:emacs}
 
 \end_inset 
 
 (X)Emacs configuration
 \layout Standard
 
 Thanks to the work of Alexander Schmolck and Prabhu Ramachandran, currently
  (X)Emacs and IPython get along very well.
  
 \layout Standard
 
 
 \series bold 
 Important note:
 \series default 
  You will need to use a recent enough version of 
 \family typewriter 
 python-mode.el
 \family default 
 , along with the file 
 \family typewriter 
 ipython.el
 \family default 
 .
  You can check that the version you have of 
 \family typewriter 
 python-mode.el
 \family default 
  is new enough by either looking at the revision number in the file itself,
  or asking for it in (X)Emacs via 
 \family typewriter 
 M-x py-version
 \family default 
 .
  Versions 4.68 and newer contain the necessary fixes for proper IPython support.
 \layout Standard
 
 The file 
 \family typewriter 
 ipython.el
 \family default 
  is included with the IPython distribution, in the documentation directory
  (where this manual resides in PDF and HTML formats).
 \layout Standard
 
 Once you put these files in your Emacs path, all you need in your 
 \family typewriter 
 .emacs
 \family default 
  file is:
 \layout Standard
 
 
 \family typewriter 
 (require 'ipython)
 \layout Standard
 
 This should give you full support for executing code snippets via IPython,
  opening IPython as your Python shell via 
 \family typewriter 
 C-c\SpecialChar ~
 !
 \family default 
 , etc.
  
 \layout Subsubsection*
 
 Notes
 \layout Itemize
 
 There is one caveat you should be aware of: you must start the IPython shell
  
 \emph on 
 before
 \emph default 
  attempting to execute any code regions via 
 \family typewriter 
 C-c\SpecialChar ~
 |
 \family default 
 .
  Simply type 
 \family typewriter 
 C-c\SpecialChar ~
 !
 \family default 
  to start IPython before passing any code regions to the interpreter, and
  you shouldn't experience any problems.
 \newline 
 This is due to a bug in Python itself, which has been fixed for Python 2.3,
  but exists as of Python 2.2.2 (reported as SF bug [ 737947 ]).
 \layout Itemize
 
 The (X)Emacs support is maintained by Alexander Schmolck, so all comments/reques
 ts should be directed to him through the IPython mailing lists.
  
 \layout Itemize
 
 This code is still somewhat experimental so it's a bit rough around the
  edges (although in practice, it works quite well).
 \layout Itemize
 
 Be aware that if you customize 
 \family typewriter 
 py-python-command
 \family default 
  previously, this value will override what 
 \family typewriter 
 ipython.el
 \family default 
  does (because loading the customization variables comes later).
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:quick_tips}
 
 \end_inset 
 
 Quick tips
 \layout Standard
 
 IPython can be used as an improved replacement for the Python prompt, and
  for that you don't really need to read any more of this manual.
  But in this section we'll try to summarize a few tips on how to make the
  most effective use of it for everyday Python development, highlighting
  things you might miss in the rest of the manual (which is getting long).
  We'll give references to parts in the manual which provide more detail
  when appropriate.
 \layout Standard
 
 The following article by Jeremy Jones provides an introductory tutorial
  about IPython:
 \newline 
 
 \begin_inset LatexCommand \htmlurl{http://www.onlamp.com/pub/a/python/2005/01/27/ipython.html}
 
 \end_inset 
 
 
 \layout Itemize
 
 The TAB key.
  TAB-completion, especially for attributes, is a convenient way to explore
  the structure of any object you're dealing with.
  Simply type 
 \family typewriter 
 object_name.<TAB>
 \family default 
  and a list of the object's attributes will be printed (see sec.
  
 \begin_inset LatexCommand \ref{sec:readline}
 
 \end_inset 
 
  for more).
  Tab completion also works on file and directory names, which combined with
  IPython's alias system allows you to do from within IPython many of the
  things you normally would need the system shell for.
  
 \layout Itemize
 
 Explore your objects.
  Typing 
 \family typewriter 
 object_name?
 \family default 
  will print all sorts of details about any object, including docstrings,
  function definition lines (for call arguments) and constructor details
  for classes.
  The magic commands 
 \family typewriter 
 %pdoc
 \family default 
 , 
 \family typewriter 
 %pdef
 \family default 
 , 
 \family typewriter 
 %psource
 \family default 
  and 
 \family typewriter 
 %pfile
 \family default 
  will respectively print the docstring, function definition line, full source
  code and the complete file for any object (when they can be found).
  If automagic is on (it is by default), you don't need to type the '
 \family typewriter 
 %
 \family default 
 ' explicitly.
  See sec.
  
 \begin_inset LatexCommand \ref{sec:dyn-object-info}
 
 \end_inset 
 
  for more.
 \layout Itemize
 
 The 
 \family typewriter 
 %run
 \family default 
  magic command allows you to run any python script and load all of its data
  directly into the interactive namespace.
  Since the file is re-read from disk each time, changes you make to it are
  reflected immediately (in contrast to the behavior of 
 \family typewriter 
 import
 \family default 
 ).
  I rarely use 
 \family typewriter 
 import
 \family default 
  for code I am testing, relying on 
 \family typewriter 
 %run
 \family default 
  instead.
  See sec.
  
 \begin_inset LatexCommand \ref{sec:magic}
 
 \end_inset 
 
  for more on this and other magic commands, or type the name of any magic
  command and ? to get details on it.
  See also sec.
  
 \begin_inset LatexCommand \ref{sec:dreload}
 
 \end_inset 
 
  for a recursive reload command.
 \newline 
 
 \family typewriter 
 %run
 \family default 
  also has special flags for timing the execution of your scripts (
 \family typewriter 
 -t
 \family default 
 ) and for executing them under the control of either Python's 
 \family typewriter 
 pdb 
 \family default 
 debugger (
 \family typewriter 
 -d
 \family default 
 ) or profiler (
 \family typewriter 
 -p
 \family default 
 ).
  With all of these, 
 \family typewriter 
 %run
 \family default 
  can be used as the main tool for efficient interactive development of code
  which you write in your editor of choice.
 \layout Itemize
 
 Use the Python debugger, 
 \family typewriter 
 pdb
 \family default 
 
 \begin_inset Foot
 collapsed true
 
 \layout Standard
 
 Thanks to Christian Hart and Matthew Arnison for the suggestions leading
  to IPython's improved debugger and profiler support.
 \end_inset 
 
 .
  The 
 \family typewriter 
 %pdb
 \family default 
  command allows you to toggle on and off the automatic invocation of an
  IPython-enhanced 
 \family typewriter 
 pdb
 \family default 
  debugger (with coloring, tab completion and more) at any uncaught exception.
  The advantage of this is that 
 \family typewriter 
 pdb
 \family default 
  starts 
 \emph on 
 inside
 \emph default 
  the function where the exception occurred, with all data still available.
  You can print variables, see code, execute statements and even walk up
  and down the call stack to track down the true source of the problem (which
  often is many layers in the stack above where the exception gets triggered).
 \newline 
 Running programs with 
 \family typewriter 
 %run
 \family default 
  and pdb active can be an efficient to develop and debug code, in many cases
  eliminating the need for 
 \family typewriter 
 print
 \family default 
  statements or external debugging tools.
  I often simply put a 
 \family typewriter 
 1/0
 \family default 
  in a place where I want to take a look so that pdb gets called, quickly
  view whatever variables I need to or test various pieces of code and then
  remove the 
 \family typewriter 
 1/0
 \family default 
 .
 \newline 
 Note also that `
 \family typewriter 
 %run -d
 \family default 
 ' activates 
 \family typewriter 
 pdb
 \family default 
  and automatically sets initial breakpoints for you to step through your
  code, watch variables, etc.
  See Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:cache_output}
 
 \end_inset 
 
  for details.
 \layout Itemize
 
 Use the output cache.
  All output results are automatically stored in a global dictionary named
  
 \family typewriter 
 Out
 \family default 
  and variables named 
 \family typewriter 
 _1
 \family default 
 , 
 \family typewriter 
 _2
 \family default 
 , etc.
  alias them.
  For example, the result of input line 4 is available either as 
 \family typewriter 
 Out[4]
 \family default 
  or as 
 \family typewriter 
 _4
 \family default 
 .
  Additionally, three variables named 
 \family typewriter 
 _
 \family default 
 , 
 \family typewriter 
 __
 \family default 
  and 
 \family typewriter 
 ___
 \family default 
  are always kept updated with the for the last three results.
  This allows you to recall any previous result and further use it for new
  calculations.
  See Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:cache_output}
 
 \end_inset 
 
  for more.
 \layout Itemize
 
 Put a '
 \family typewriter 
 ;
 \family default 
 ' at the end of a line to supress the printing of output.
  This is useful when doing calculations which generate long output you are
  not interested in seeing.
  The 
 \family typewriter 
 _*
 \family default 
  variables and the 
 \family typewriter 
 Out[]
 \family default 
  list do get updated with the contents of the output, even if it is not
  printed.
  You can thus still access the generated results this way for further processing.
 \layout Itemize
 
 A similar system exists for caching input.
  All input is stored in a global list called 
 \family typewriter 
 In
 \family default 
  , so you can re-execute lines 22 through 28 plus line 34 by typing 
 \family typewriter 
 'exec In[22:29]+In[34]'
 \family default 
  (using Python slicing notation).
  If you need to execute the same set of lines often, you can assign them
  to a macro with the 
 \family typewriter 
 %macro
 \family default 
  
 \family typewriter 
 function.
  
 \family default 
 See sec.
  
 \begin_inset LatexCommand \ref{sec:cache_input}
 
 \end_inset 
 
  for more.
 \layout Itemize
 
 Use your input history.
  The 
 \family typewriter 
 %hist
 \family default 
  command can show you all previous input, without line numbers if desired
  (option 
 \family typewriter 
 -n
 \family default 
 ) so you can directly copy and paste code either back in IPython or in a
  text editor.
  You can also save all your history by turning on logging via 
 \family typewriter 
 %logstart
 \family default 
 ; these logs can later be either reloaded as IPython sessions or used as
  code for your programs.
 \layout Itemize
 
 Define your own macros with 
 \family typewriter 
 %macro
 \family default 
 .
  This can be useful for automating sequences of expressions when working
  interactively.
 \layout Itemize
 
 Define your own system aliases.
  Even though IPython gives you access to your system shell via the 
 \family typewriter 
 !
 \family default 
  prefix, it is convenient to have aliases to the system commands you use
  most often.
  This allows you to work seamlessly from inside IPython with the same commands
  you are used to in your system shell.
 \newline 
 IPython comes with some pre-defined aliases and a complete system for changing
  directories, both via a stack (see 
 \family typewriter 
 %pushd
 \family default 
 , 
 \family typewriter 
 %popd
 \family default 
  and 
 \family typewriter 
 %ds
 \family default 
 ) and via direct 
 \family typewriter 
 %cd
 \family default 
 .
  The latter keeps a history of visited directories and allows you to go
  to any previously visited one.
 \layout Itemize
 
 Use Python to manipulate the results of system commands.
  The `
 \family typewriter 
 !!
 \family default 
 ' special syntax, and the 
 \family typewriter 
 %sc
 \family default 
  and 
 \family typewriter 
 %sx
 \family default 
  magic commands allow you to capture system output into Python variables.
 \layout Itemize
 
 Expand python variables when calling the shell (either via 
 \family typewriter 
 `!'
 \family default 
  and 
 \family typewriter 
 `!!'
 \family default 
  or via aliases) by prepending a 
 \family typewriter 
 $
 \family default 
  in front of them.
  You can also expand complete python expressions.
  See sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sub:System-shell-access}
 
 \end_inset 
 
  for more.
 \layout Itemize
 
 Use profiles to maintain different configurations (modules to load, function
  definitions, option settings) for particular tasks.
  You can then have customized versions of IPython for specific purposes.
  See sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:profiles}
 
 \end_inset 
 
  for more.
 \layout Itemize
 
 Embed IPython in your programs.
  A few lines of code are enough to load a complete IPython inside your own
  programs, giving you the ability to work with your data interactively after
  automatic processing has been completed.
  See sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:embed}
 
 \end_inset 
 
  for more.
 \layout Itemize
 
 Use the Python profiler.
  When dealing with performance issues, the 
 \family typewriter 
 %run
 \family default 
  command with a 
 \family typewriter 
 -p
 \family default 
  option allows you to run complete programs under the control of the Python
  profiler.
  The 
 \family typewriter 
 %prun
 \family default 
  command does a similar job for single Python expressions (like function
  calls).
 \layout Itemize
 
 Use 
 \family typewriter 
 %edit
 \family default 
  to have almost multiline editing.
  While IPython doesn't support true multiline editing, this command allows
  you to call an editor on the spot, and IPython will execute the code you
  type in there as if it were typed interactively.
 \layout Itemize
 
 Use the IPython.demo.Demo class to load any Python script as an interactive
  demo.
  With a minimal amount of simple markup, you can control the execution of
  the script, stopping as needed.
  See sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:interactive-demos}
 
 \end_inset 
 
  for more.
 \layout Standard
 
 
 \series bold 
 Effective logging:
 \series default 
  a very useful suggestion sent in by Robert Kern follows
 \layout Standard
 
 I recently happened on a nifty way to keep tidy per-project log files.
  I made a profile for my project (which is called "parkfield").
 \layout LyX-Code
 
 include ipythonrc
 \layout LyX-Code
 
 logfile '' # cancel earlier logfile invocation
 \layout LyX-Code
 
 execute import time
 \layout LyX-Code
 
 execute __cmd = '/Users/kern/research/logfiles/parkfield-%s.log rotate'
 \layout LyX-Code
 
 execute __IP.magic_logstart(__cmd % time.strftime('%Y-%m-%d'))
 \layout Standard
 
 I also added a shell alias for convenience:
 \layout LyX-Code
 
 alias parkfield="ipython -pylab -profile parkfield"
 \layout Standard
 
 Now I have a nice little directory with everything I ever type in, organized
  by project and date.
 \layout Standard
 
 
 \series bold 
 Contribute your own: 
 \series default 
 If you have your own favorite tip on using IPython efficiently for a certain
  task (especially things which can't be done in the normal Python interpreter),
  don't hesitate to send it!
 \layout Section
 
 Command-line use
 \layout Standard
 
 You start IPython with the command:
 \layout Standard
 
 
 \family typewriter 
 $ ipython [options] files
 \layout Standard
 
 If invoked with no options, it executes all the files listed in sequence
  and drops you into the interpreter while still acknowledging any options
  you may have set in your ipythonrc file.
  This behavior is different from standard Python, which when called as 
 \family typewriter 
 python -i
 \family default 
  will only execute one file and ignore your configuration setup.
 \layout Standard
 
 Please note that some of the configuration options are not available at
  the command line, simply because they are not practical here.
  Look into your ipythonrc configuration file for details on those.
  This file typically installed in the 
 \family typewriter 
 $HOME/.ipython
 \family default 
  directory.
  For Windows users, 
 \family typewriter 
 $HOME
 \family default 
  resolves to 
 \family typewriter 
 C:
 \backslash 
 
 \backslash 
 Documents and Settings
 \backslash 
 
 \backslash 
 YourUserName
 \family default 
  in most instances.
  In the rest of this text, we will refer to this directory as 
 \family typewriter 
 IPYTHONDIR
 \family default 
 .
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:threading-opts}
 
 \end_inset 
 
 Special Threading Options
 \layout Standard
 
 The following special options are ONLY valid at the beginning of the command
  line, and not later.
  This is because they control the initial- ization of ipython itself, before
  the normal option-handling mechanism is active.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -gthread,\SpecialChar ~
 -qthread,\SpecialChar ~
 -wthread,\SpecialChar ~
 -pylab:
 \family default 
 \series default 
  Only 
 \emph on 
 one
 \emph default 
  of these can be given, and it can only be given as the first option passed
  to IPython (it will have no effect in any other position).
  They provide threading support for the GTK Qt and WXPython toolkits, and
  for the matplotlib library.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  With any of the first three options, IPython starts running a separate
  thread for the graphical toolkit's operation, so that you can open and
  control graphical elements from within an IPython command line, without
  blocking.
  All three provide essentially the same functionality, respectively for
  GTK, QT and WXWidgets (via their Python interfaces).
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
+ Note that with 
+\family typewriter 
+-wthread
+\family default 
+, you can additionally use the -wxversion option to request a specific version
+ of wx to be used.
+ This requires that you have the 
+\family typewriter 
+wxversion
+\family default 
+ Python module installed, which is part of recent wxPython distributions.
+\layout List
+\labelwidthstring 00.00.0000
+
+\SpecialChar ~
  If 
 \family typewriter 
 -pylab
 \family default 
  is given, IPython loads special support for the mat plotlib library (
 \begin_inset LatexCommand \htmlurl{http://matplotlib.sourceforge.net}
 
 \end_inset 
 
 ), allowing interactive usage of any of its backends as defined in the user's
  
 \family typewriter 
 ~/.matplotlib/matplotlibrc
 \family default 
  file.
  It automatically activates GTK, Qt or WX threading for IPyhton if the choice
  of matplotlib backend requires it.
  It also modifies the 
 \family typewriter 
 %run
 \family default 
  command to correctly execute (without blocking) any matplotlib-based script
  which calls 
 \family typewriter 
 show()
 \family default 
  at the end.
  
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -tk
 \family default 
 \series default 
  The 
 \family typewriter 
 -g/q/wthread
 \family default 
  options, and 
 \family typewriter 
 -pylab
 \family default 
  (if matplotlib is configured to use GTK, Qt or WX), will normally block
  Tk graphical interfaces.
  This means that when either GTK, Qt or WX threading is active, any attempt
  to open a Tk GUI will result in a dead window, and possibly cause the Python
  interpreter to crash.
  An extra option, 
 \family typewriter 
 -tk
 \family default 
 , is available to address this issue.
  It can 
 \emph on 
 only
 \emph default 
  be given as a 
 \emph on 
 second
 \emph default 
  option after any of the above (
 \family typewriter 
 -gthread
 \family default 
 , 
 \family typewriter 
 -wthread
 \family default 
  or 
 \family typewriter 
 -pylab
 \family default 
 ).
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  If 
 \family typewriter 
 -tk
 \family default 
  is given, IPython will try to coordinate Tk threading with GTK, Qt or WX.
  This is however potentially unreliable, and you will have to test on your
  platform and Python configuration to determine whether it works for you.
  Debian users have reported success, apparently due to the fact that Debian
  builds all of Tcl, Tk, Tkinter and Python with pthreads support.
  Under other Linux environments (such as Fedora Core 2/3), this option has
  caused random crashes and lockups of the Python interpreter.
  Under other operating systems (Mac OSX and Windows), you'll need to try
  it to find out, since currently no user reports are available.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  There is unfortunately no way for IPython to determine at run time whether
  
 \family typewriter 
 -tk
 \family default 
  will work reliably or not, so you will need to do some experiments before
  relying on it for regular work.
  
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:cmd-line-opts}
 
 \end_inset 
 
 Regular Options
 \layout Standard
 
 After the above threading options have been given, regular options can follow
  in any order.
  All options can be abbreviated to their shortest non-ambiguous form and
  are case-sensitive.
  One or two dashes can be used.
  Some options have an alternate short form, indicated after a 
 \family typewriter 
 |
 \family default 
 .
 \layout Standard
 
 Most options can also be set from your ipythonrc configuration file.
  See the provided example for more details on what the options do.
  Options given at the command line override the values set in the ipythonrc
  file.
 \layout Standard
 
 All options with a 
 \family typewriter 
 [no]
 \family default 
  prepended can be specified in negated form (
 \family typewriter 
 -nooption
 \family default 
  instead of 
 \family typewriter 
 -option
 \family default 
 ) to turn the feature off.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -help
 \family default 
 \series default 
 : print a help message and exit.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -pylab:
 \family default 
 \series default 
  this can 
 \emph on 
 only
 \emph default 
  be given as the 
 \emph on 
 first
 \emph default 
  option passed to IPython (it will have no effect in any other position).
  It adds special support for the matplotlib library (
 \begin_inset LatexCommand \htmlurl[http://matplotlib.sourceforge.net]{http://matplotlib.sourceforge.net}
 
 \end_inset 
 
 ), allowing interactive usage of any of its backends as defined in the user's
  
 \family typewriter 
 .matplotlibrc
 \family default 
  file.
  It automatically activates GTK or WX threading for IPyhton if the choice
  of matplotlib backend requires it.
  It also modifies the 
 \family typewriter 
 %run
 \family default 
  command to correctly execute (without blocking) any matplotlib-based script
  which calls 
 \family typewriter 
 show()
 \family default 
  at the end.
  See Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:matplotlib-support}
 
 \end_inset 
 
  for more details.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -autocall <val>:
 \family default 
 \series default 
  Make IPython automatically call any callable object even if you didn't
  type explicit parentheses.
  For example, `str 43' becomes `str(43)' automatically.
  The value can be `0' to disable the feature, `1' for 
 \emph on 
 smart
 \emph default 
  autocall, where it is not applied if there are no more arguments on the
  line, and `2' for 
 \emph on 
 full
 \emph default 
  autocall, where all callable objects are automatically called (even if
  no arguments are present).
  The default is `1'.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]autoindent:
 \family default 
 \series default 
  Turn automatic indentation on/off.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]automagic
 \series default 
 :
 \family default 
  make magic commands automatic (without needing their first character to
  be 
 \family typewriter 
 %
 \family default 
 ).
  Type 
 \family typewriter 
 %magic
 \family default 
  at the IPython prompt for more information.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]autoedit_syntax:
 \family default 
 \series default 
  When a syntax error occurs after editing a file, automatically open the
  file to the trouble causing line for convenient fixing.
  
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]banner
 \series default 
 :
 \family default 
  Print the initial information banner (default on).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -c\SpecialChar ~
 <command>:
 \family default 
 \series default 
  execute the given command string, and set sys.argv to 
 \family typewriter 
 ['c']
 \family default 
 .
  This is similar to the 
 \family typewriter 
 -c
 \family default 
  option in the normal Python interpreter.
  
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -cache_size|cs\SpecialChar ~
 <n>
 \series default 
 :
 \family default 
  size of the output cache (maximum number of entries to hold in memory).
  The default is 1000, you can change it permanently in your config file.
  Setting it to 0 completely disables the caching system, and the minimum
  value accepted is 20 (if you provide a value less than 20, it is reset
  to 0 and a warning is issued) This limit is defined because otherwise you'll
  spend more time re-flushing a too small cache than working.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -classic|cl
 \series default 
 :
 \family default 
  Gives IPython a similar feel to the classic Python prompt.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -colors\SpecialChar ~
 <scheme>:
 \family default 
 \series default 
  Color scheme for prompts and exception reporting.
  Currently implemented: NoColor, Linux and LightBG.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]color_info:
 \family default 
 \series default 
  IPython can display information about objects via a set of functions, and
  optionally can use colors for this, syntax highlighting source code and
  various other elements.
  However, because this information is passed through a pager (like 'less')
  and many pagers get confused with color codes, this option is off by default.
  You can test it and turn it on permanently in your ipythonrc file if it
  works for you.
  As a reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
  that in RedHat 7.2 doesn't.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Test it and turn it on permanently if it works with your system.
  The magic function 
 \family typewriter 
 %color_info
 \family default 
  allows you to toggle this interactively for testing.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]debug
 \family default 
 \series default 
 : Show information about the loading process.
  Very useful to pin down problems with your configuration files or to get
  details about session restores.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]deep_reload
 \series default 
 :
 \family default 
  IPython can use the 
 \family typewriter 
 deep_reload
 \family default 
  module which reloads changes in modules recursively (it replaces the 
 \family typewriter 
 reload()
 \family default 
  function, so you don't need to change anything to use it).
  
 \family typewriter 
 deep_reload()
 \family default 
  forces a full reload of modules whose code may have changed, which the
  default 
 \family typewriter 
 reload()
 \family default 
  function does not.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  When deep_reload is off, IPython will use the normal 
 \family typewriter 
 reload()
 \family default 
 , but deep_reload will still be available as 
 \family typewriter 
 dreload()
 \family default 
 .
  This feature is off by default [which means that you have both normal 
 \family typewriter 
 reload()
 \family default 
  and 
 \family typewriter 
 dreload()
 \family default 
 ].
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -editor\SpecialChar ~
 <name>
 \family default 
 \series default 
 : Which editor to use with the 
 \family typewriter 
 %edit
 \family default 
  command.
  By default, IPython will honor your 
 \family typewriter 
 EDITOR
 \family default 
  environment variable (if not set, vi is the Unix default and notepad the
  Windows one).
  Since this editor is invoked on the fly by IPython and is meant for editing
  small code snippets, you may want to use a small, lightweight editor here
  (in case your default 
 \family typewriter 
 EDITOR
 \family default 
  is something like Emacs).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -ipythondir\SpecialChar ~
 <name>
 \series default 
 :
 \family default 
  name of your IPython configuration directory 
 \family typewriter 
 IPYTHONDIR
 \family default 
 .
  This can also be specified through the environment variable 
 \family typewriter 
 IPYTHONDIR
 \family default 
 .
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -log|l
 \family default 
 \series default 
 : generate a log file of all input.
  The file is named 
 \family typewriter 
 ipython_log.py
 \family default 
  in your current directory (which prevents logs from multiple IPython sessions
  from trampling each other).
  You can use this to later restore a session by loading your logfile as
  a file to be executed with option 
 \family typewriter 
 -logplay
 \family default 
  (see below).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -logfile|lf\SpecialChar ~
 <name>
 \series default 
 : 
 \family default 
 specify the name of your logfile.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -logplay|lp\SpecialChar ~
 <name>
 \series default 
 :
 \family default 
  you can replay a previous log.
  For restoring a session as close as possible to the state you left it in,
  use this option (don't just run the logfile).
  With 
 \family typewriter 
 -logplay
 \family default 
 , IPython will try to reconstruct the previous working environment in full,
  not just execute the commands in the logfile.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  When a session is restored, logging is automatically turned on again with
  the name of the logfile it was invoked with (it is read from the log header).
  So once you've turned logging on for a session, you can quit IPython and
  reload it as many times as you want and it will continue to log its history
  and restore from the beginning every time.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Caveats: there are limitations in this option.
  The history variables 
 \family typewriter 
 _i*
 \family default 
 ,
 \family typewriter 
 _*
 \family default 
  and 
 \family typewriter 
 _dh
 \family default 
  don't get restored properly.
  In the future we will try to implement full session saving by writing and
  retrieving a 'snapshot' of the memory state of IPython.
  But our first attempts failed because of inherent limitations of Python's
  Pickle module, so this may have to wait.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]messages
 \series default 
 :
 \family default 
  Print messages which IPython collects about its startup process (default
  on).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]pdb
 \family default 
 \series default 
 : Automatically call the pdb debugger after every uncaught exception.
  If you are used to debugging using pdb, this puts you automatically inside
  of it after any call (either in IPython or in code called by it) which
  triggers an exception which goes uncaught.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]pprint
 \series default 
 :
 \family default 
  ipython can optionally use the pprint (pretty printer) module for displaying
  results.
  pprint tends to give a nicer display of nested data structures.
  If you like it, you can turn it on permanently in your config file (default
  off).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -profile|p <name>
 \series default 
 :
 \family default 
  assume that your config file is 
 \family typewriter 
 ipythonrc-<name>
 \family default 
  (looks in current dir first, then in 
 \family typewriter 
 IPYTHONDIR
 \family default 
 ).
  This is a quick way to keep and load multiple config files for different
  tasks, especially if you use the include option of config files.
  You can keep a basic 
 \family typewriter 
 IPYTHONDIR/ipythonrc
 \family default 
  file and then have other 'profiles' which include this one and load extra
  things for particular tasks.
  For example:
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \SpecialChar ~
  
 \family default 
 1.
 
 \family typewriter 
  $HOME/.ipython/ipythonrc
 \family default 
  : load basic things you always want.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \SpecialChar ~
  
 \family default 
 2.
 
 \family typewriter 
  $HOME/.ipython/ipythonrc-math
 \family default 
  : load (1) and basic math-related modules.
  
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \SpecialChar ~
  
 \family default 
 3.
 
 \family typewriter 
  $HOME/.ipython/ipythonrc-numeric
 \family default 
  : load (1) and Numeric and plotting modules.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Since it is possible to create an endless loop by having circular file
  inclusions, IPython will stop if it reaches 15 recursive inclusions.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -prompt_in1|pi1\SpecialChar ~
 <string>:
 \family default 
 \series default 
  Specify the string used for input prompts.
  Note that if you are using numbered prompts, the number is represented
  with a '
 \backslash 
 #' in the string.
  Don't forget to quote strings with spaces embedded in them.
  Default: '
 \family typewriter 
 In\SpecialChar ~
 [
 \backslash 
 #]:
 \family default 
 '.
  Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:prompts}
 
 \end_inset 
 
  discusses in detail all the available escapes to customize your prompts.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -prompt_in2|pi2\SpecialChar ~
 <string>:
 \family default 
 \series default 
  Similar to the previous option, but used for the continuation prompts.
  The special sequence '
 \family typewriter 
 
 \backslash 
 D
 \family default 
 ' is similar to '
 \family typewriter 
 
 \backslash 
 #
 \family default 
 ', but with all digits replaced dots (so you can have your continuation
  prompt aligned with your input prompt).
  Default: '
 \family typewriter 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 .
 \backslash 
 D.:
 \family default 
 ' (note three spaces at the start for alignment with '
 \family typewriter 
 In\SpecialChar ~
 [
 \backslash 
 #]
 \family default 
 ').
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -prompt_out|po\SpecialChar ~
 <string>:
 \family default 
 \series default 
  String used for output prompts, also uses numbers like 
 \family typewriter 
 prompt_in1
 \family default 
 .
  Default: '
 \family typewriter 
 Out[
 \backslash 
 #]:
 \family default 
 '
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -quick
 \family default 
 \series default 
 : start in bare bones mode (no config file loaded).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -rcfile\SpecialChar ~
 <name>
 \series default 
 :
 \family default 
  name of your IPython resource configuration file.
  Normally IPython loads ipythonrc (from current directory) or
 \family typewriter 
  IPYTHONDIR/ipythonrc
 \family default 
 .
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  If the loading of your config file fails, IPython starts with a bare bones
  configuration (no modules loaded at all).
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -[no]readline
 \family default 
 \series default 
 : use the readline library, which is needed to support name completion and
  command history, among other things.
  It is enabled by default, but may cause problems for users of X/Emacs in
  Python comint or shell buffers.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Note that X/Emacs 'eterm' buffers (opened with 
 \family typewriter 
 M-x\SpecialChar ~
 term
 \family default 
 ) support IPython's readline and syntax coloring fine, only 'emacs' (
 \family typewriter 
 M-x\SpecialChar ~
 shell
 \family default 
  and 
 \family typewriter 
 C-c\SpecialChar ~
 !
 \family default 
 ) buffers do not.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -screen_length|sl\SpecialChar ~
 <n>
 \series default 
 :
 \family default 
  number of lines of your screen.
  This is used to control printing of very long strings.
  Strings longer than this number of lines will be sent through a pager instead
  of directly printed.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  The default value for this is 0, which means IPython will auto-detect your
  screen size every time it needs to print certain potentially long strings
  (this doesn't change the behavior of the 'print' keyword, it's only triggered
  internally).
  If for some reason this isn't working well (it needs curses support), specify
  it yourself.
  Otherwise don't change the default.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -separate_in|si\SpecialChar ~
 <string>
 \series default 
 :
 \family default 
  separator before input prompts.
  Default: '
 \family typewriter 
 
 \backslash 
 n
 \family default 
 '
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -separate_out|so\SpecialChar ~
 <string>
 \family default 
 \series default 
 : separator before output prompts.
  Default: nothing.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -separate_out2|so2\SpecialChar ~
 <string>
 \series default 
 :
 \family default 
  separator after output prompts.
  Default: nothing.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  For these three options, use the value 0 to specify no separator.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -nosep
 \series default 
 : 
 \family default 
 shorthand for 
 \family typewriter 
 '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'
 \family default 
 .
  Simply removes all input/output separators.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -upgrade
 \family default 
 \series default 
 : allows you to upgrade your 
 \family typewriter 
 IPYTHONDIR
 \family default 
  configuration when you install a new version of IPython.
  Since new versions may include new command line options or example files,
  this copies updated ipythonrc-type files.
  However, it backs up (with a 
 \family typewriter 
 .old
 \family default 
  extension) all files which it overwrites so that you can merge back any
  customizations you might have in your personal files.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 -Version
 \series default 
 :
 \family default 
  print version information and exit.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
--xmode <modename>
+-wxversion\SpecialChar ~
+<string>:
+\family default 
+\series default 
+ Select a specific version of wxPython (used in conjunction with 
+\family typewriter 
+-wthread
+\family default 
+).
+ Requires the wxversion module, part of recent wxPython distributions
+\layout List
+\labelwidthstring 00.00.0000
+
+
+\family typewriter 
+\series bold 
+-xmode\SpecialChar ~
+<modename>
 \series default 
 :
 \family default 
  Mode for exception reporting.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Valid modes: Plain, Context and Verbose.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Plain: similar to python's normal traceback printing.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Context: prints 5 lines of context source code around each line in the
  traceback.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  Verbose: similar to Context, but additionally prints the variables currently
  visible where the exception happened (shortening their strings if too long).
  This can potentially be very slow, if you happen to have a huge data structure
  whose string representation is complex to compute.
  Your computer may appear to freeze for a while with cpu usage at 100%.
  If this occurs, you can cancel the traceback with Ctrl-C (maybe hitting
  it more than once).
 \layout Section
 
 Interactive use
 \layout Standard
 
 
 \series bold 
 Warning
 \series default 
 : IPython relies on the existence of a global variable called 
 \family typewriter 
 __IP
 \family default 
  which controls the shell itself.
  If you redefine 
 \family typewriter 
 __IP
 \family default 
  to anything, bizarre behavior will quickly occur.
 \layout Standard
 
 Other than the above warning, IPython is meant to work as a drop-in replacement
  for the standard interactive interpreter.
  As such, any code which is valid python should execute normally under IPython
  (cases where this is not true should be reported as bugs).
  It does, however, offer many features which are not available at a standard
  python prompt.
  What follows is a list of these.
 \layout Subsection
 
 Caution for Windows users
 \layout Standard
 
 Windows, unfortunately, uses the `
 \family typewriter 
 
 \backslash 
 
 \family default 
 ' character as a path separator.
  This is a terrible choice, because `
 \family typewriter 
 
 \backslash 
 
 \family default 
 ' also represents the escape character in most modern programming languages,
  including Python.
  For this reason, issuing many of the commands discussed below (especially
  magics which affect the filesystem) with `
 \family typewriter 
 
 \backslash 
 
 \family default 
 ' in them will cause strange errors.
 \layout Standard
 
 A partial solution is to use instead the `
 \family typewriter 
 /
 \family default 
 ' character as a path separator, which Windows recognizes in 
 \emph on 
 most
 \emph default 
  situations.
  However, in Windows commands `
 \family typewriter 
 /
 \family default 
 ' flags options, so you can not use it for the root directory.
  This means that paths beginning at the root must be typed in a contrived
  manner like:
 \newline 
 
 \family typewriter 
 %copy 
 \backslash 
 opt/foo/bar.txt 
 \backslash 
 tmp
 \layout Standard
 
 There is no sensible thing IPython can do to truly work around this flaw
  in Windows
 \begin_inset Foot
 collapsed true
 
 \layout Standard
 
 If anyone comes up with a 
 \emph on 
 clean
 \emph default 
  solution which works consistently and does not negatively impact other
  platforms at all, I'll gladly accept a patch.
 \end_inset 
 
 .
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:magic}
 
 \end_inset 
 
 Magic command system
 \layout Standard
 
 IPython will treat any line whose first character is a 
 \family typewriter 
 %
 \family default 
  as a special call to a 'magic' function.
  These allow you to control the behavior of IPython itself, plus a lot of
  system-type features.
  They are all prefixed with a 
 \family typewriter 
 %
 \family default 
  character, but parameters are given without parentheses or quotes.
 \layout Standard
 
 Example: typing 
 \family typewriter 
 '%cd mydir'
 \family default 
  (without the quotes) changes you working directory to 
 \family typewriter 
 'mydir'
 \family default 
 , if it exists.
 \layout Standard
 
 If you have 'automagic' enabled (in your 
 \family typewriter 
 ipythonrc
 \family default 
  file, via the command line option 
 \family typewriter 
 -automagic 
 \family default 
 or with the 
 \family typewriter 
 %automagic
 \family default 
  function), you don't need to type in the 
 \family typewriter 
 %
 \family default 
  explicitly.
  IPython will scan its internal list of magic functions and call one if
  it exists.
  With automagic on you can then just type '
 \family typewriter 
 cd mydir
 \family default 
 ' to go to directory '
 \family typewriter 
 mydir
 \family default 
 '.
  The automagic system has the lowest possible precedence in name searches,
  so defining an identifier with the same name as an existing magic function
  will shadow it for automagic use.
  You can still access the shadowed magic function by explicitly using the
  
 \family typewriter 
 %
 \family default 
  character at the beginning of the line.
 \layout Standard
 
 An example (with automagic on) should clarify all this:
 \layout LyX-Code
 
 In [1]: cd ipython # %cd is called by automagic
 \layout LyX-Code
 
 /home/fperez/ipython
 \layout LyX-Code
 
 In [2]: cd=1 # now cd is just a variable
 \layout LyX-Code
 
 In [3]: cd ..
  # and doesn't work as a function anymore
 \layout LyX-Code
 
 ------------------------------------------------------------
 \layout LyX-Code
 
     File "<console>", line 1
 \layout LyX-Code
 
       cd ..
 \layout LyX-Code
 
           ^
 \layout LyX-Code
 
 SyntaxError: invalid syntax
 \layout LyX-Code
 
 \layout LyX-Code
 
 In [4]: %cd ..
  # but %cd always works
 \layout LyX-Code
 
 /home/fperez
 \layout LyX-Code
 
 In [5]: del cd # if you remove the cd variable
 \layout LyX-Code
 
 In [6]: cd ipython # automagic can work again
 \layout LyX-Code
 
 /home/fperez/ipython
 \layout Standard
 
 You can define your own magic functions to extend the system.
  The following is a snippet of code which shows how to do it.
  It is provided as file 
 \family typewriter 
 example-magic.py
 \family default 
  in the examples directory:
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 codelist{examples/example-magic.py}
 \end_inset 
 
 
 \layout Standard
 
 You can also define your own aliased names for magic functions.
  In your 
 \family typewriter 
 ipythonrc
 \family default 
  file, placing a line like:
 \layout Standard
 
 
 \family typewriter 
 execute __IP.magic_cl = __IP.magic_clear
 \layout Standard
 
 will define 
 \family typewriter 
 %cl
 \family default 
  as a new name for 
 \family typewriter 
 %clear
 \family default 
 .
 \layout Standard
 
 Type 
 \family typewriter 
 %magic
 \family default 
  for more information, including a list of all available magic functions
  at any time and their docstrings.
  You can also type 
 \family typewriter 
 %magic_function_name?
 \family default 
  (see sec.
  
 \begin_inset LatexCommand \ref{sec:dyn-object-info}
 
 \end_inset 
 
  for information on the 
 \family typewriter 
 '?'
 \family default 
  system) to get information about any particular magic function you are
  interested in.
 \layout Subsubsection
 
 Magic commands
 \layout Standard
 
 The rest of this section is automatically generated for each release from
  the docstrings in the IPython code.
  Therefore the formatting is somewhat minimal, but this method has the advantage
  of having information always in sync with the code.
 \layout Standard
 
 A list of all the magic commands available in IPython's 
 \emph on 
 default
 \emph default 
  installation follows.
  This is similar to what you'll see by simply typing 
 \family typewriter 
 %magic
 \family default 
  at the prompt, but that will also give you information about magic commands
  you may have added as part of your personal customizations.
 \layout Standard
 
 
 \begin_inset Include \input{magic.tex}
 preview false
 
 \end_inset 
 
 
 \layout Subsection
 
 Access to the standard Python help
 \layout Standard
 
 As of Python 2.1, a help system is available with access to object docstrings
  and the Python manuals.
  Simply type 
 \family typewriter 
 'help'
 \family default 
  (no quotes) to access it.
  You can also type 
 \family typewriter 
 help(object)
 \family default 
  to obtain information about a given object, and 
 \family typewriter 
 help('keyword')
 \family default 
  for information on a keyword.
  As noted in sec.
  
 \begin_inset LatexCommand \ref{sec:help-access}
 
 \end_inset 
 
 , you need to properly configure your environment variable 
 \family typewriter 
 PYTHONDOCS
 \family default 
  for this feature to work correctly.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:dyn-object-info}
 
 \end_inset 
 
 Dynamic object information
 \layout Standard
 
 Typing 
 \family typewriter 
 ?word
 \family default 
  or 
 \family typewriter 
 word?
 \family default 
  prints detailed information about an object.
  If certain strings in the object are too long (docstrings, code, etc.) they
  get snipped in the center for brevity.
  This system gives access variable types and values, full source code for
  any object (if available), function prototypes and other useful information.
 \layout Standard
 
 Typing 
 \family typewriter 
 ??word
 \family default 
  or 
 \family typewriter 
 word??
 \family default 
  gives access to the full information without snipping long strings.
  Long strings are sent to the screen through the 
 \family typewriter 
 less
 \family default 
  pager if longer than the screen and printed otherwise.
  On systems lacking the 
 \family typewriter 
 less
 \family default 
  command, IPython uses a very basic internal pager.
 \layout Standard
 
 The following magic functions are particularly useful for gathering information
  about your working environment.
  You can get more details by typing 
 \family typewriter 
 %magic
 \family default 
  or querying them individually (use 
 \family typewriter 
 %function_name?
 \family default 
  with or without the 
 \family typewriter 
 %
 \family default 
 ), this is just a summary:
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 %pdoc\SpecialChar ~
 <object>
 \family default 
 \series default 
 : Print (or run through a pager if too long) the docstring for an object.
  If the given object is a class, it will print both the class and the constructo
 r docstrings.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 %pdef\SpecialChar ~
 <object>
 \family default 
 \series default 
 : Print the definition header for any callable object.
  If the object is a class, print the constructor information.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 %psource\SpecialChar ~
 <object>
 \family default 
 \series default 
 : Print (or run through a pager if too long) the source code for an object.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 %pfile\SpecialChar ~
 <object>
 \family default 
 \series default 
 : Show the entire source file where an object was defined via a pager, opening
  it at the line where the object definition begins.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 %who/%whos
 \family default 
 \series default 
 : These functions give information about identifiers you have defined interactiv
 ely (not things you loaded or defined in your configuration files).
  
 \family typewriter 
 %who
 \family default 
  just prints a list of identifiers and 
 \family typewriter 
 %whos
 \family default 
  prints a table with some basic details about each identifier.
 \layout Standard
 
 Note that the dynamic object information functions (
 \family typewriter 
 ?/??, %pdoc, %pfile, %pdef, %psource
 \family default 
 ) give you access to documentation even on things which are not really defined
  as separate identifiers.
  Try for example typing 
 \family typewriter 
 {}.get?
 \family default 
  or after doing 
 \family typewriter 
 import os
 \family default 
 , type 
 \family typewriter 
 os.path.abspath??
 \family default 
 .
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:readline}
 
 \end_inset 
 
 Readline-based features
 \layout Standard
 
 These features require the GNU readline library, so they won't work if your
  Python installation lacks readline support.
  We will first describe the default behavior IPython uses, and then how
  to change it to suit your preferences.
 \layout Subsubsection
 
 Command line completion
 \layout Standard
 
 At any time, hitting TAB will complete any available python commands or
  variable names, and show you a list of the possible completions if there's
  no unambiguous one.
  It will also complete filenames in the current directory if no python names
  match what you've typed so far.
 \layout Subsubsection
 
 Search command history
 \layout Standard
 
 IPython provides two ways for searching through previous input and thus
  reduce the need for repetitive typing:
 \layout Enumerate
 
 Start typing, and then use 
 \family typewriter 
 Ctrl-p
 \family default 
  (previous,up) and 
 \family typewriter 
 Ctrl-n
 \family default 
  (next,down) to search through only the history items that match what you've
  typed so far.
  If you use 
 \family typewriter 
 Ctrl-p/Ctrl-n
 \family default 
  at a blank prompt, they just behave like normal arrow keys.
 \layout Enumerate
 
 Hit 
 \family typewriter 
 Ctrl-r
 \family default 
 : opens a search prompt.
  Begin typing and the system searches your history for lines that contain
  what you've typed so far, completing as much as it can.
 \layout Subsubsection
 
 Persistent command history across sessions
 \layout Standard
 
 IPython will save your input history when it leaves and reload it next time
  you restart it.
  By default, the history file is named 
 \family typewriter 
 $IPYTHONDIR/history
 \family default 
 , but if you've loaded a named profile, '
 \family typewriter 
 -PROFILE_NAME
 \family default 
 ' is appended to the name.
  This allows you to keep separate histories related to various tasks: commands
  related to numerical work will not be clobbered by a system shell history,
  for example.
 \layout Subsubsection
 
 Autoindent
 \layout Standard
 
 IPython can recognize lines ending in ':' and indent the next line, while
  also un-indenting automatically after 'raise' or 'return'.
  
 \layout Standard
 
 This feature uses the readline library, so it will honor your 
 \family typewriter 
 ~/.inputrc
 \family default 
  configuration (or whatever file your 
 \family typewriter 
 INPUTRC
 \family default 
  variable points to).
  Adding the following lines to your 
 \family typewriter 
 .inputrc
 \family default 
  file can make indenting/unindenting more convenient (
 \family typewriter 
 M-i
 \family default 
  indents, 
 \family typewriter 
 M-u
 \family default 
  unindents):
 \layout Standard
 
 
 \family typewriter 
 $if Python
 \newline 
 "
 \backslash 
 M-i": "\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 " 
 \newline 
 "
 \backslash 
 M-u": "
 \backslash 
 d
 \backslash 
 d
 \backslash 
 d
 \backslash 
 d" 
 \newline 
 $endif
 \layout Standard
 
 Note that there are 4 spaces between the quote marks after 
 \family typewriter 
 "M-i"
 \family default 
  above.
 \layout Standard
 
 
 \series bold 
 Warning:
 \series default 
  this feature is ON by default, but it can cause problems with the pasting
  of multi-line indented code (the pasted code gets re-indented on each line).
  A magic function 
 \family typewriter 
 %autoindent
 \family default 
  allows you to toggle it on/off at runtime.
  You can also disable it permanently on in your 
 \family typewriter 
 ipythonrc
 \family default 
  file (set 
 \family typewriter 
 autoindent 0
 \family default 
 ).
 \layout Subsubsection
 
 Customizing readline behavior
 \layout Standard
 
 All these features are based on the GNU readline library, which has an extremely
  customizable interface.
  Normally, readline is configured via a file which defines the behavior
  of the library; the details of the syntax for this can be found in the
  readline documentation available with your system or on the Internet.
  IPython doesn't read this file (if it exists) directly, but it does support
  passing to readline valid options via a simple interface.
  In brief, you can customize readline by setting the following options in
  your 
 \family typewriter 
 ipythonrc
 \family default 
  configuration file (note that these options can 
 \emph on 
 not
 \emph default 
  be specified at the command line):
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 readline_parse_and_bind:
 \family default 
 \series default 
  this option can appear as many times as you want, each time defining a
  string to be executed via a 
 \family typewriter 
 readline.parse_and_bind()
 \family default 
  command.
  The syntax for valid commands of this kind can be found by reading the
  documentation for the GNU readline library, as these commands are of the
  kind which readline accepts in its configuration file.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 readline_remove_delims:
 \family default 
 \series default 
  a string of characters to be removed from the default word-delimiters list
  used by readline, so that completions may be performed on strings which
  contain them.
  Do not change the default value unless you know what you're doing.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 readline_omit__names
 \family default 
 \series default 
 : when tab-completion is enabled, hitting 
 \family typewriter 
 <tab>
 \family default 
  after a '
 \family typewriter 
 .
 \family default 
 ' in a name will complete all attributes of an object, including all the
  special methods whose names include double underscores (like 
 \family typewriter 
 __getitem__
 \family default 
  or 
 \family typewriter 
 __class__
 \family default 
 ).
  If you'd rather not see these names by default, you can set this option
  to 1.
  Note that even when this option is set, you can still see those names by
  explicitly typing a 
 \family typewriter 
 _
 \family default 
  after the period and hitting 
 \family typewriter 
 <tab>
 \family default 
 : '
 \family typewriter 
 name._<tab>
 \family default 
 ' will always complete attribute names starting with '
 \family typewriter 
 _
 \family default 
 '.
 \layout List
 \labelwidthstring 00.00.0000
 
 \SpecialChar ~
  This option is off by default so that new users see all attributes of any
  objects they are dealing with.
 \layout Standard
 
 You will find the default values along with a corresponding detailed explanation
  in your 
 \family typewriter 
 ipythonrc
 \family default 
  file.
 \layout Subsection
 
 Session logging and restoring
 \layout Standard
 
 You can log all input from a session either by starting IPython with the
  command line switches 
 \family typewriter 
 -log
 \family default 
  or 
 \family typewriter 
 -logfile 
 \family default 
 (see sec.
  
 \begin_inset LatexCommand \ref{sec:cmd-line-opts}
 
 \end_inset 
 
 )or by activating the logging at any moment with the magic function 
 \family typewriter 
 %logstart
 \family default 
 .
  
 \layout Standard
 
 Log files can later be reloaded with the 
 \family typewriter 
 -logplay
 \family default 
  option and IPython will attempt to 'replay' the log by executing all the
  lines in it, thus restoring the state of a previous session.
  This feature is not quite perfect, but can still be useful in many cases.
 \layout Standard
 
 The log files can also be used as a way to have a permanent record of any
  code you wrote while experimenting.
  Log files are regular text files which you can later open in your favorite
  text editor to extract code or to 'clean them up' before using them to
  replay a session.
 \layout Standard
 
 The 
 \family typewriter 
 %logstart
 \family default 
  function for activating logging in mid-session is used as follows:
 \layout Standard
 
 
 \family typewriter 
 %logstart [log_name [log_mode]]
 \layout Standard
 
 If no name is given, it defaults to a file named 
 \family typewriter 
 'log'
 \family default 
  in your IPYTHONDIR directory, in 
 \family typewriter 
 'rotate'
 \family default 
  mode (see below).
 \layout Standard
 
 '
 \family typewriter 
 %logstart name
 \family default 
 ' saves to file 
 \family typewriter 
 'name'
 \family default 
  in 
 \family typewriter 
 'backup'
 \family default 
  mode.
  It saves your history up to that point and then continues logging.
 \layout Standard
 
 
 \family typewriter 
 %logstart
 \family default 
  takes a second optional parameter: logging mode.
  This can be one of (note that the modes are given unquoted):
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 over
 \family default 
 : overwrite existing 
 \family typewriter 
 log_name
 \family default 
 .
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 backup
 \family default 
 : rename (if exists) to 
 \family typewriter 
 log_name~
 \family default 
  and start 
 \family typewriter 
 log_name
 \family default 
 .
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 append
 \family default 
 : well, that says it.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 rotate
 \family default 
 : create rotating logs 
 \family typewriter 
 log_name
 \family default 
 .
 \family typewriter 
 1~
 \family default 
 , 
 \family typewriter 
 log_name.2~
 \family default 
 , etc.
 \layout Standard
 
 The 
 \family typewriter 
 %logoff
 \family default 
  and 
 \family typewriter 
 %logon
 \family default 
  functions allow you to temporarily stop and resume logging to a file which
  had previously been started with 
 \family typewriter 
 %logstart
 \family default 
 .
  They will fail (with an explanation) if you try to use them before logging
  has been started.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sub:System-shell-access}
 
 \end_inset 
 
 System shell access
 \layout Standard
 
 Any input line beginning with a 
 \family typewriter 
 !
 \family default 
  character is passed verbatim (minus the 
 \family typewriter 
 !
 \family default 
 , of course) to the underlying operating system.
  For example, typing 
 \family typewriter 
 !ls
 \family default 
  will run 
 \family typewriter 
 'ls'
 \family default 
  in the current directory.
 \layout Subsubsection
 
 Manual capture of command output
 \layout Standard
 
 If the input line begins with 
 \emph on 
 two
 \emph default 
  exclamation marks, 
 \family typewriter 
 !!
 \family default 
 , the command is executed but its output is captured and returned as a python
  list, split on newlines.
  Any output sent by the subprocess to standard error is printed separately,
  so that the resulting list only captures standard output.
  The 
 \family typewriter 
 !!
 \family default 
  syntax is a shorthand for the 
 \family typewriter 
 %sx
 \family default 
  magic command.
 \layout Standard
 
 Finally, the 
 \family typewriter 
 %sc
 \family default 
  magic (short for `shell capture') is similar to 
 \family typewriter 
 %sx
 \family default 
 , but allowing more fine-grained control of the capture details, and storing
  the result directly into a named variable.
 \layout Standard
 
 See Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:magic}
 
 \end_inset 
 
  for details on the magics 
 \family typewriter 
 %sc
 \family default 
  and 
 \family typewriter 
 %sx
 \family default 
 , or use IPython's own help (
 \family typewriter 
 sc?
 \family default 
  and 
 \family typewriter 
 sx?
 \family default 
 ) for further details.
 \layout Standard
 
 IPython also allows you to expand the value of python variables when making
  system calls.
  Any python variable or expression which you prepend with 
 \family typewriter 
 $
 \family default 
  will get expanded before the system call is made.
  
 \layout Standard
 
 
 \family typewriter 
 In [1]: pyvar='Hello world'
 \newline 
 In [2]: !echo "A python variable: $pyvar" 
 \newline 
 A python variable: Hello world
 \layout Standard
 
 If you want the shell to actually see a literal 
 \family typewriter 
 $
 \family default 
 , you need to type it twice:
 \layout Standard
 
 
 \family typewriter 
 In [3]: !echo "A system variable: $$HOME" 
 \newline 
 A system variable: /home/fperez
 \layout Standard
 
 You can pass arbitrary expressions, though you'll need to delimit them with
  
 \family typewriter 
 {}
 \family default 
  if there is ambiguity as to the extent of the expression:
 \layout Standard
 
 
 \family typewriter 
 In [5]: x=10
 \newline 
 In [6]: y=20
 \newline 
 In [13]: !echo $x+y 
 \newline 
 10+y 
 \newline 
 In [7]: !echo ${x+y} 
 \newline 
 30 
 \layout Standard
 
 Even object attributes can be expanded:
 \layout Standard
 
 
 \family typewriter 
 In [12]: !echo $sys.argv 
 \newline 
 [/home/fperez/usr/bin/ipython] 
 \layout Subsection
 
 System command aliases
 \layout Standard
 
 The 
 \family typewriter 
 %alias
 \family default 
  magic function and the 
 \family typewriter 
 alias
 \family default 
  option in the 
 \family typewriter 
 ipythonrc
 \family default 
  configuration file allow you to define magic functions which are in fact
  system shell commands.
  These aliases can have parameters.
  
 \layout Standard
 
 '
 \family typewriter 
 %alias alias_name cmd
 \family default 
 ' defines '
 \family typewriter 
 alias_name
 \family default 
 ' as an alias for '
 \family typewriter 
 cmd
 \family default 
 ' 
 \layout Standard
 
 Then, typing '
 \family typewriter 
 %alias_name params
 \family default 
 ' will execute the system command '
 \family typewriter 
 cmd params
 \family default 
 ' (from your underlying operating system).
  
 \layout Standard
 
 You can also define aliases with parameters using 
 \family typewriter 
 %s
 \family default 
  specifiers (one per parameter).
  The following example defines the 
 \family typewriter 
 %parts
 \family default 
  function as an alias to the command '
 \family typewriter 
 echo first %s second %s
 \family default 
 ' where each 
 \family typewriter 
 %s
 \family default 
  will be replaced by a positional parameter to the call to 
 \family typewriter 
 %parts:
 \layout Standard
 
 
 \family typewriter 
 In [1]: alias parts echo first %s second %s
 \newline 
 In [2]: %parts A B
 \newline 
 first A second B 
 \newline 
 In [3]: %parts A 
 \newline 
 Incorrect number of arguments: 2 expected.
  
 \newline 
 parts is an alias to: 'echo first %s second %s' 
 \layout Standard
 
 If called with no parameters, 
 \family typewriter 
 %alias
 \family default 
  prints the table of currently defined aliases.
 \layout Standard
 
 The 
 \family typewriter 
 %rehash/rehashx
 \family default 
  magics allow you to load your entire 
 \family typewriter 
 $PATH
 \family default 
  as ipython aliases.
  See their respective docstrings (or sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:magic}
 
 \end_inset 
 
  for further details).
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:dreload}
 
 \end_inset 
 
 Recursive reload
 \layout Standard
 
 The 
 \family typewriter 
 %dreload
 \family default 
  command does a recursive reload of a module: changes made to the module
  since you imported will actually be available without having to exit.
 \layout Subsection
 
 Verbose and colored exception traceback printouts
 \layout Standard
 
 IPython provides the option to see very detailed exception tracebacks, which
  can be especially useful when debugging large programs.
  You can run any Python file with the 
 \family typewriter 
 %run
 \family default 
  function to benefit from these detailed tracebacks.
  Furthermore, both normal and verbose tracebacks can be colored (if your
  terminal supports it) which makes them much easier to parse visually.
 \layout Standard
 
 See the magic 
 \family typewriter 
 xmode
 \family default 
  and 
 \family typewriter 
 colors
 \family default 
  functions for details (just type 
 \family typewriter 
 %magic
 \family default 
 ).
 \layout Standard
 
 These features are basically a terminal version of Ka-Ping Yee's 
 \family typewriter 
 cgitb
 \family default 
  module, now part of the standard Python library.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:cache_input}
 
 \end_inset 
 
 Input caching system
 \layout Standard
 
 IPython offers numbered prompts (In/Out) with input and output caching.
  All input is saved and can be retrieved as variables (besides the usual
  arrow key recall).
 \layout Standard
 
 The following GLOBAL variables always exist (so don't overwrite them!):
  
 \family typewriter 
 _i
 \family default 
 : stores previous input.
  
 \family typewriter 
 _ii
 \family default 
 : next previous.
  
 \family typewriter 
 _iii
 \family default 
 : next-next previous.
  
 \family typewriter 
 _ih
 \family default 
  : a list of all input 
 \family typewriter 
 _ih[n]
 \family default 
  is the input from line 
 \family typewriter 
 n
 \family default 
  and this list is aliased to the global variable 
 \family typewriter 
 In
 \family default 
 .
  If you overwrite 
 \family typewriter 
 In
 \family default 
  with a variable of your own, you can remake the assignment to the internal
  list with a simple 
 \family typewriter 
 'In=_ih'
 \family default 
 .
 \layout Standard
 
 Additionally, global variables named 
 \family typewriter 
 _i<n>
 \family default 
  are dynamically created (
 \family typewriter 
 <n>
 \family default 
  being the prompt counter), such that 
 \newline 
 
 \family typewriter 
 _i<n> == _ih[<n>] == In[<n>].
 \layout Standard
 
 For example, what you typed at prompt 14 is available as 
 \family typewriter 
 _i14,
 \family default 
  
 \family typewriter 
 _ih[14]
 \family default 
  and 
 \family typewriter 
 In[14]
 \family default 
 .
 \layout Standard
 
 This allows you to easily cut and paste multi line interactive prompts by
  printing them out: they print like a clean string, without prompt characters.
  You can also manipulate them like regular variables (they are strings),
  modify or exec them (typing 
 \family typewriter 
 'exec _i9'
 \family default 
  will re-execute the contents of input prompt 9, '
 \family typewriter 
 exec In[9:14]+In[18]
 \family default 
 ' will re-execute lines 9 through 13 and line 18).
 \layout Standard
 
 You can also re-execute multiple lines of input easily by using the magic
  
 \family typewriter 
 %macro
 \family default 
  function (which automates the process and allows re-execution without having
  to type '
 \family typewriter 
 exec
 \family default 
 ' every time).
  The macro system also allows you to re-execute previous lines which include
  magic function calls (which require special processing).
  Type 
 \family typewriter 
 %macro?
 \family default 
  or see sec.
  
 \begin_inset LatexCommand \ref{sec:magic}
 
 \end_inset 
 
  for more details on the macro system.
 \layout Standard
 
 A history function 
 \family typewriter 
 %hist
 \family default 
  allows you to see any part of your input history by printing a range of
  the 
 \family typewriter 
 _i
 \family default 
  variables.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:cache_output}
 
 \end_inset 
 
 Output caching system
 \layout Standard
 
 For output that is returned from actions, a system similar to the input
  cache exists but using 
 \family typewriter 
 _
 \family default 
  instead of 
 \family typewriter 
 _i
 \family default 
 .
  Only actions that produce a result (NOT assignments, for example) are cached.
  If you are familiar with Mathematica, IPython's 
 \family typewriter 
 _
 \family default 
  variables behave exactly like Mathematica's 
 \family typewriter 
 %
 \family default 
  variables.
 \layout Standard
 
 The following GLOBAL variables always exist (so don't overwrite them!):
  
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 _
 \family default 
 \series default 
  (a 
 \emph on 
 single
 \emph default 
  underscore) : stores previous output, like Python's default interpreter.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 __
 \family default 
 \series default 
  (two underscores): next previous.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 ___
 \family default 
 \series default 
  (three underscores): next-next previous.
 \layout Standard
 
 Additionally, global variables named 
 \family typewriter 
 _<n> 
 \family default 
 are dynamically created (
 \family typewriter 
 <n>
 \family default 
  being the prompt counter), such that the result of output 
 \family typewriter 
 <n>
 \family default 
  is always available as 
 \family typewriter 
 _<n>
 \family default 
  (don't use the angle brackets, just the number, e.g.
  
 \family typewriter 
 _21
 \family default 
 ).
 \layout Standard
 
 These global variables are all stored in a global dictionary (not a list,
  since it only has entries for lines which returned a result) available
  under the names 
 \family typewriter 
 _oh
 \family default 
  and 
 \family typewriter 
 Out
 \family default 
  (similar to 
 \family typewriter 
 _ih
 \family default 
  and 
 \family typewriter 
 In
 \family default 
 ).
  So the output from line 12 can be obtained as 
 \family typewriter 
 _12
 \family default 
 , 
 \family typewriter 
 Out[12]
 \family default 
  or 
 \family typewriter 
 _oh[12]
 \family default 
 .
  If you accidentally overwrite the 
 \family typewriter 
 Out
 \family default 
  variable you can recover it by typing 
 \family typewriter 
 'Out=_oh
 \family default 
 ' at the prompt.
 \layout Standard
 
 This system obviously can potentially put heavy memory demands on your system,
  since it prevents Python's garbage collector from removing any previously
  computed results.
  You can control how many results are kept in memory with the option (at
  the command line or in your 
 \family typewriter 
 ipythonrc
 \family default 
  file) 
 \family typewriter 
 cache_size
 \family default 
 .
  If you set it to 0, the whole system is completely disabled and the prompts
  revert to the classic 
 \family typewriter 
 '>>>'
 \family default 
  of normal Python.
 \layout Subsection
 
 Directory history
 \layout Standard
 
 Your history of visited directories is kept in the global list 
 \family typewriter 
 _dh
 \family default 
 , and the magic 
 \family typewriter 
 %cd
 \family default 
  command can be used to go to any entry in that list.
  The 
 \family typewriter 
 %dhist
 \family default 
  command allows you to view this history.
 \layout Subsection
 
 Automatic parentheses and quotes
 \layout Standard
 
 These features were adapted from Nathan Gray's LazyPython.
  They are meant to allow less typing for common situations.
 \layout Subsubsection
 
 Automatic parentheses
 \layout Standard
 
 Callable objects (i.e.
  functions, methods, etc) can be invoked like this (notice the commas between
  the arguments):
 \layout Standard
 
 
 \family typewriter 
 >>> callable_ob arg1, arg2, arg3 
 \layout Standard
 
 and the input will be translated to this: 
 \layout Standard
 
 
 \family typewriter 
 --> callable_ob(arg1, arg2, arg3) 
 \layout Standard
 
 You can force automatic parentheses by using '/' as the first character
  of a line.
  For example:
 \layout Standard
 
 
 \family typewriter 
 >>> /globals # becomes 'globals()' 
 \layout Standard
 
 Note that the '/' MUST be the first character on the line! This won't work:
  
 \layout Standard
 
 
 \family typewriter 
 >>> print /globals # syntax error
 \layout Standard
 
 In most cases the automatic algorithm should work, so you should rarely
  need to explicitly invoke /.
  One notable exception is if you are trying to call a function with a list
  of tuples as arguments (the parenthesis will confuse IPython): 
 \layout Standard
 
 
 \family typewriter 
 In [1]: zip (1,2,3),(4,5,6) # won't work 
 \layout Standard
 
 but this will work: 
 \layout Standard
 
 
 \family typewriter 
 In [2]: /zip (1,2,3),(4,5,6)
 \newline 
 ------> zip ((1,2,3),(4,5,6)) 
 \newline 
 Out[2]= [(1, 4), (2, 5), (3, 6)] 
 \layout Standard
 
 IPython tells you that it has altered your command line by displaying the
  new command line preceded by 
 \family typewriter 
 -->
 \family default 
 .
  e.g.: 
 \layout Standard
 
 
 \family typewriter 
 In [18]: callable list
 \newline 
 -------> callable (list)
 \layout Subsubsection
 
 Automatic quoting 
 \layout Standard
 
 You can force automatic quoting of a function's arguments by using 
 \family typewriter 
 `,'
 \family default 
  or 
 \family typewriter 
 `;'
 \family default 
  as the first character of a line.
  For example: 
 \layout Standard
 
 
 \family typewriter 
 >>> ,my_function /home/me # becomes my_function("/home/me") 
 \layout Standard
 
 If you use 
 \family typewriter 
 `;'
 \family default 
  instead, the whole argument is quoted as a single string (while 
 \family typewriter 
 `,'
 \family default 
  splits on whitespace):
 \layout Standard
 
 
 \family typewriter 
 >>> ,my_function a b c # becomes my_function("a","b","c")
 \layout Standard
 
 
 \family typewriter 
 >>> ;my_function a b c # becomes my_function("a b c")
 \layout Standard
 
 Note that the `
 \family typewriter 
 ,
 \family default 
 ' or `
 \family typewriter 
 ;
 \family default 
 ' MUST be the first character on the line! This won't work: 
 \layout Standard
 
 
 \family typewriter 
 >>> x = ,my_function /home/me # syntax error
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:customization}
 
 \end_inset 
 
 Customization
 \layout Standard
 
 As we've already mentioned, IPython reads a configuration file which can
  be specified at the command line (
 \family typewriter 
 -rcfile
 \family default 
 ) or which by default is assumed to be called 
 \family typewriter 
 ipythonrc
 \family default 
 .
  Such a file is looked for in the current directory where IPython is started
  and then in your 
 \family typewriter 
 IPYTHONDIR
 \family default 
 , which allows you to have local configuration files for specific projects.
  In this section we will call these types of configuration files simply
  rcfiles (short for resource configuration file).
 \layout Standard
 
 The syntax of an rcfile is one of key-value pairs separated by whitespace,
  one per line.
  Lines beginning with a 
 \family typewriter 
 #
 \family default 
  are ignored as comments, but comments can 
 \series bold 
 not
 \series default 
  be put on lines with data (the parser is fairly primitive).
  Note that these are not python files, and this is deliberate, because it
  allows us to do some things which would be quite tricky to implement if
  they were normal python files.
 \layout Standard
 
 First, an rcfile can contain permanent default values for almost all command
  line options (except things like 
 \family typewriter 
 -help
 \family default 
  or 
 \family typewriter 
 -Version
 \family default 
 ).
  Sec\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:cmd-line-opts}
 
 \end_inset 
 
  contains a description of all command-line options.
  However, values you explicitly specify at the command line override the
  values defined in the rcfile.
 \layout Standard
 
 Besides command line option values, the rcfile can specify values for certain
  extra special options which are not available at the command line.
  These options are briefly described below.
  
 \layout Standard
 
 Each of these options may appear as many times as you need it in the file.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 include\SpecialChar ~
 <file1>\SpecialChar ~
 <file2>\SpecialChar ~
 ...
 \family default 
 \series default 
 : you can name 
 \emph on 
 other 
 \emph default 
 rcfiles you want to recursively load up to 15 levels (don't use the 
 \family typewriter 
 <>
 \family default 
  brackets in your names!).
  This feature allows you to define a 'base' rcfile with general options
  and special-purpose files which can be loaded only when needed with particular
  configuration options.
  To make this more convenient, IPython accepts the 
 \family typewriter 
 -profile <name>
 \family default 
  option (abbreviates to 
 \family typewriter 
 -p <name
 \family default 
 >)
 \family typewriter 
  which
 \family default 
  tells it to look for an rcfile named 
 \family typewriter 
 ipythonrc-<name>
 \family default 
 .
  
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 import_mod\SpecialChar ~
 <mod1>\SpecialChar ~
 <mod2>\SpecialChar ~
 ...
 \family default 
 \series default 
 : import modules with '
 \family typewriter 
 import
 \family default 
  
 \family typewriter 
 <mod1>,<mod2>,...
 \family default 
 ' 
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 import_some\SpecialChar ~
 <mod>\SpecialChar ~
 <f1>\SpecialChar ~
 <f2>\SpecialChar ~
 ...
 \family default 
 \series default 
 : import functions with '
 \family typewriter 
 from <mod> import
 \family default 
  
 \family typewriter 
 <f1>,<f2>,...
 \family default 
 ' 
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 import_all\SpecialChar ~
 <mod1>\SpecialChar ~
 <mod2>\SpecialChar ~
 ...
 \family default 
 \series default 
 : for each module listed import functions with '
 \family typewriter 
 from <mod> import *
 \family default 
 ' 
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 execute\SpecialChar ~
 <python\SpecialChar ~
 code>
 \family default 
 \series default 
 : give any single-line python code to be executed.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 execfile\SpecialChar ~
 <filename>
 \family default 
 \series default 
 : execute the python file given with an '
 \family typewriter 
 execfile(filename)
 \family default 
 ' command.
  Username expansion is performed on the given names.
  So if you need any amount of extra fancy customization that won't fit in
  any of the above 'canned' options, you can just put it in a separate python
  file and execute it.
 \layout List
 \labelwidthstring 00.00.0000
 
 
 \family typewriter 
 \series bold 
 alias\SpecialChar ~
 <alias_def>
 \family default 
 \series default 
 : this is equivalent to calling '
 \family typewriter 
 %alias\SpecialChar ~
 <alias_def>
 \family default 
 ' at the IPython command line.
  This way, from within IPython you can do common system tasks without having
  to exit it or use the 
 \family typewriter 
 !
 \family default 
  escape.
  IPython isn't meant to be a shell replacement, but it is often very useful
  to be able to do things with files while testing code.
  This gives you the flexibility to have within IPython any aliases you may
  be used to under your normal system shell.
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:ipytonrc-sample}
 
 \end_inset 
 
 Sample 
 \family typewriter 
 ipythonrc
 \family default 
  file
 \layout Standard
 
 The default rcfile, called 
 \family typewriter 
 ipythonrc
 \family default 
  and supplied in your 
 \family typewriter 
 IPYTHONDIR 
 \family default 
 directory contains lots of comments on all of these options.
  We reproduce it here for reference:
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 codelist{../IPython/UserConfig/ipythonrc}
 \end_inset 
 
 
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:prompts}
 
 \end_inset 
 
 Fine-tuning your prompt
 \layout Standard
 
 IPython's prompts can be customized using a syntax similar to that of the
  
 \family typewriter 
 bash
 \family default 
  shell.
  Many of 
 \family typewriter 
 bash
 \family default 
 's escapes are supported, as well as a few additional ones.
  We list them below:
 \layout Description
 
 
 \backslash 
 # the prompt/history count number
 \layout Description
 
 
 \backslash 
 D the prompt/history count, with the actual digits replaced by dots.
  Used mainly in continuation prompts (prompt_in2)
 \layout Description
 
 
 \backslash 
 w the current working directory
 \layout Description
 
 
 \backslash 
 W the basename of current working directory
 \layout Description
 
 
 \backslash 
 X
 \emph on 
 n
 \emph default 
  where 
 \begin_inset Formula $n=0\ldots5.$
 \end_inset 
 
  The current working directory, with 
 \family typewriter 
 $HOME
 \family default 
  replaced by 
 \family typewriter 
 ~
 \family default 
 , and filtered out to contain only 
 \begin_inset Formula $n$
 \end_inset 
 
  path elements
 \layout Description
 
 
 \backslash 
 Y
 \emph on 
 n
 \emph default 
  Similar to 
 \backslash 
 X
 \emph on 
 n
 \emph default 
 , but with the 
 \begin_inset Formula $n+1$
 \end_inset 
 
  element included if it is 
 \family typewriter 
 ~
 \family default 
  (this is similar to the behavior of the %c
 \emph on 
 n
 \emph default 
  escapes in 
 \family typewriter 
 tcsh
 \family default 
 )
 \layout Description
 
 
 \backslash 
 u the username of the current user
 \layout Description
 
 
 \backslash 
 $ if the effective UID is 0, a #, otherwise a $
 \layout Description
 
 
 \backslash 
 h the hostname up to the first `.'
 \layout Description
 
 
 \backslash 
 H the hostname
 \layout Description
 
 
 \backslash 
 n a newline
 \layout Description
 
 
 \backslash 
 r a carriage return
 \layout Description
 
 
 \backslash 
 v IPython version string
 \layout Standard
 
 In addition to these, ANSI color escapes can be insterted into the prompts,
  as 
 \family typewriter 
 
 \backslash 
 C_
 \emph on 
 ColorName
 \family default 
 \emph default 
 .
  The list of valid color names is: Black, Blue, Brown, Cyan, DarkGray, Green,
  LightBlue, LightCyan, LightGray, LightGreen, LightPurple, LightRed, NoColor,
  Normal, Purple, Red, White, Yellow.
 \layout Standard
 
 Finally, IPython supports the evaluation of arbitrary expressions in your
  prompt string.
  The prompt strings are evaluated through the syntax of PEP 215, but basically
  you can use 
 \family typewriter 
 $x.y
 \family default 
  to expand the value of 
 \family typewriter 
 x.y
 \family default 
 , and for more complicated expressions you can use braces: 
 \family typewriter 
 ${foo()+x}
 \family default 
  will call function 
 \family typewriter 
 foo
 \family default 
  and add to it the value of 
 \family typewriter 
 x
 \family default 
 , before putting the result into your prompt.
  For example, using 
 \newline 
 
 \family typewriter 
 prompt_in1 '${commands.getoutput("uptime")}
 \backslash 
 nIn [
 \backslash 
 #]: '
 \newline 
 
 \family default 
 will print the result of the uptime command on each prompt (assuming the
  
 \family typewriter 
 commands
 \family default 
  module has been imported in your 
 \family typewriter 
 ipythonrc
 \family default 
  file).
 \layout Subsubsection
 
 Prompt examples
 \layout Standard
 
 The following options in an ipythonrc file will give you IPython's default
  prompts:
 \layout Standard
 
 
 \family typewriter 
 prompt_in1 'In [
 \backslash 
 #]:'
 \newline 
 prompt_in2 '\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 .
 \backslash 
 D.:'
 \newline 
 prompt_out 'Out[
 \backslash 
 #]:'
 \layout Standard
 
 which look like this:
 \layout Standard
 
 
 \family typewriter 
 In [1]: 1+2
 \newline 
 Out[1]: 3
 \layout Standard
 
 
 \family typewriter 
 In [2]: for i in (1,2,3):
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 ...: \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 print i,
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 ...:
 \newline 
 1 2 3
 \layout Standard
 
 These will give you a very colorful prompt with path information:
 \layout Standard
 
 
 \family typewriter 
 #prompt_in1 '
 \backslash 
 C_Red
 \backslash 
 u
 \backslash 
 C_Blue[
 \backslash 
 C_Cyan
 \backslash 
 Y1
 \backslash 
 C_Blue]
 \backslash 
 C_LightGreen
 \backslash 
 #>'
 \newline 
 prompt_in2 ' ..
 \backslash 
 D>'
 \newline 
 prompt_out '<
 \backslash 
 #>' 
 \layout Standard
 
 which look like this:
 \layout Standard
 
 
 \family typewriter 
 \color red
 fperez
 \color blue
 [
 \color cyan
 ~/ipython
 \color blue
 ]
 \color green
 1>
 \color default
  1+2
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 
 \color red
 <1>
 \color default
  3
 \newline 
 
 \color red
 fperez
 \color blue
 [
 \color cyan
 ~/ipython
 \color blue
 ]
 \color green
 2>
 \color default
  for i in (1,2,3):
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 
 \color green
 ...>
 \color default
  \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 print i,
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 
 \color green
 ...>
 \color default
 
 \newline 
 1 2 3
 \layout Standard
 
 The following shows the usage of dynamic expression evaluation:
 \layout Subsection
 
 
 \begin_inset LatexCommand \label{sec:profiles}
 
 \end_inset 
 
 IPython profiles
 \layout Standard
 
 As we already mentioned, IPython supports the 
 \family typewriter 
 -profile
 \family default 
  command-line option (see sec.
  
 \begin_inset LatexCommand \ref{sec:cmd-line-opts}
 
 \end_inset 
 
 ).
  A profile is nothing more than a particular configuration file like your
  basic 
 \family typewriter 
 ipythonrc
 \family default 
  one, but with particular customizations for a specific purpose.
  When you start IPython with '
 \family typewriter 
 ipython -profile <name>
 \family default 
 ', it assumes that in your 
 \family typewriter 
 IPYTHONDIR
 \family default 
  there is a file called 
 \family typewriter 
 ipythonrc-<name>
 \family default 
 , and loads it instead of the normal 
 \family typewriter 
 ipythonrc
 \family default 
 .
 \layout Standard
 
 This system allows you to maintain multiple configurations which load modules,
  set options, define functions, etc.
  suitable for different tasks and activate them in a very simple manner.
  In order to avoid having to repeat all of your basic options (common things
  that don't change such as your color preferences, for example), any profile
  can include another configuration file.
  The most common way to use profiles is then to have each one include your
  basic 
 \family typewriter 
 ipythonrc
 \family default 
  file as a starting point, and then add further customizations.
 \layout Standard
 
 In sections 
 \begin_inset LatexCommand \ref{sec:syntax-extensions}
 
 \end_inset 
 
  and 
 \begin_inset LatexCommand \ref{sec:Gnuplot}
 
 \end_inset 
 
  we discuss some particular profiles which come as part of the standard
  IPython distribution.
  You may also look in your 
 \family typewriter 
 IPYTHONDIR
 \family default 
  directory, any file whose name begins with 
 \family typewriter 
 ipythonrc-
 \family default 
  is a profile.
  You can use those as examples for further customizations to suit your own
  needs.
 \layout Section
 
 
 \begin_inset OptArg
 collapsed false
 
 \layout Standard
 
 IPython as default...
 \end_inset 
 
 IPython as your default Python environment
 \layout Standard
 
 Python honors the environment variable 
 \family typewriter 
 PYTHONSTARTUP 
 \family default 
 and will execute at startup the file referenced by this variable.
  If you put at the end of this file the following two lines of code:
 \layout Standard
 
 
 \family typewriter 
 import IPython
 \newline 
 IPython.Shell.IPShell().mainloop(sys_exit=1)
 \layout Standard
 
 then IPython will be your working environment anytime you start Python.
  The 
 \family typewriter 
 sys_exit=1
 \family default 
  is needed to have IPython issue a call to 
 \family typewriter 
 sys.exit()
 \family default 
  when it finishes, otherwise you'll be back at the normal Python '
 \family typewriter 
 >>>
 \family default 
 ' prompt
 \begin_inset Foot
 collapsed true
 
 \layout Standard
 
 Based on an idea by Holger Krekel.
 \end_inset 
 
 .
 \layout Standard
 
 This is probably useful to developers who manage multiple Python versions
  and don't want to have correspondingly multiple IPython versions.
  Note that in this mode, there is no way to pass IPython any command-line
  options, as those are trapped first by Python itself.
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:embed}
 
 \end_inset 
 
 Embedding IPython
 \layout Standard
 
 It is possible to start an IPython instance 
 \emph on 
 inside
 \emph default 
  your own Python programs.
  This allows you to evaluate dynamically the state of your code, operate
  with your variables, analyze them, etc.
  Note however that any changes you make to values while in the shell do
  
 \emph on 
 not
 \emph default 
  propagate back to the running code, so it is safe to modify your values
  because you won't break your code in bizarre ways by doing so.
 \layout Standard
 
 This feature allows you to easily have a fully functional python environment
  for doing object introspection anywhere in your code with a simple function
  call.
  In some cases a simple print statement is enough, but if you need to do
  more detailed analysis of a code fragment this feature can be very valuable.
 \layout Standard
 
 It can also be useful in scientific computing situations where it is common
  to need to do some automatic, computationally intensive part and then stop
  to look at data, plots, etc
 \begin_inset Foot
 collapsed true
 
 \layout Standard
 
 This functionality was inspired by IDL's combination of the 
 \family typewriter 
 stop
 \family default 
  keyword and the 
 \family typewriter 
 .continue
 \family default 
  executive command, which I have found very useful in the past, and by a
  posting on comp.lang.python by cmkl <cmkleffner-AT-gmx.de> on Dec.
  06/01 concerning similar uses of pyrepl.
 \end_inset 
 
 .
  Opening an IPython instance will give you full access to your data and
  functions, and you can resume program execution once you are done with
  the interactive part (perhaps to stop again later, as many times as needed).
 \layout Standard
 
 The following code snippet is the bare minimum you need to include in your
  Python programs for this to work (detailed examples follow later):
 \layout LyX-Code
 
 from IPython.Shell import IPShellEmbed
 \layout LyX-Code
 
 ipshell = IPShellEmbed()
 \layout LyX-Code
 
 ipshell() # this call anywhere in your program will start IPython
 \layout Standard
 
 You can run embedded instances even in code which is itself being run at
  the IPython interactive prompt with '
 \family typewriter 
 %run\SpecialChar ~
 <filename>
 \family default 
 '.
  Since it's easy to get lost as to where you are (in your top-level IPython
  or in your embedded one), it's a good idea in such cases to set the in/out
  prompts to something different for the embedded instances.
  The code examples below illustrate this.
 \layout Standard
 
 You can also have multiple IPython instances in your program and open them
  separately, for example with different options for data presentation.
  If you close and open the same instance multiple times, its prompt counters
  simply continue from each execution to the next.
 \layout Standard
 
 Please look at the docstrings in the 
 \family typewriter 
 Shell.py
 \family default 
  module for more details on the use of this system.
 \layout Standard
 
 The following sample file illustrating how to use the embedding functionality
  is provided in the examples directory as 
 \family typewriter 
 example-embed.py
 \family default 
 .
  It should be fairly self-explanatory:
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 codelist{examples/example-embed.py}
 \end_inset 
 
 
 \layout Standard
 
 Once you understand how the system functions, you can use the following
  code fragments in your programs which are ready for cut and paste:
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 codelist{examples/example-embed-short.py}
 \end_inset 
 
 
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:using-pdb}
 
 \end_inset 
 
 Using the Python debugger (
 \family typewriter 
 pdb
 \family default 
 )
 \layout Subsection
 
 Running entire programs via 
 \family typewriter 
 pdb
 \layout Standard
 
 
 \family typewriter 
 pdb
 \family default 
 , the Python debugger, is a powerful interactive debugger which allows you
  to step through code, set breakpoints, watch variables, etc.
  IPython makes it very easy to start any script under the control of 
 \family typewriter 
 pdb
 \family default 
 , regardless of whether you have wrapped it into a 
 \family typewriter 
 `main()'
 \family default 
  function or not.
  For this, simply type 
 \family typewriter 
 `%run -d myscript'
 \family default 
  at an IPython prompt.
  See the 
 \family typewriter 
 %run
 \family default 
  command's documentation (via 
 \family typewriter 
 `%run?'
 \family default 
  or in Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:magic}
 
 \end_inset 
 
 ) for more details, including how to control where 
 \family typewriter 
 pdb
 \family default 
  will stop execution first.
 \layout Standard
 
 For more information on the use of the 
 \family typewriter 
 pdb
 \family default 
  debugger, read the included 
 \family typewriter 
 pdb.doc
 \family default 
  file (part of the standard Python distribution).
  On a stock Linux system it is located at 
 \family typewriter 
 /usr/lib/python2.3/pdb.doc
 \family default 
 , but the easiest way to read it is by using the 
 \family typewriter 
 help()
 \family default 
  function of the 
 \family typewriter 
 pdb
 \family default 
  module as follows (in an IPython prompt):
 \layout Standard
 
 
 \family typewriter 
 In [1]: import pdb
 \newline 
 In [2]: pdb.help()
 \layout Standard
 
 This will load the 
 \family typewriter 
 pdb.doc
 \family default 
  document in a file viewer for you automatically.
 \layout Subsection
 
 Automatic invocation of 
 \family typewriter 
 pdb
 \family default 
  on exceptions
 \layout Standard
 
 IPython, if started with the 
 \family typewriter 
 -pdb
 \family default 
  option (or if the option is set in your rc file) can call the Python 
 \family typewriter 
 pdb
 \family default 
  debugger every time your code triggers an uncaught exception
 \begin_inset Foot
 collapsed true
 
 \layout Standard
 
 Many thanks to Christopher Hart for the request which prompted adding this
  feature to IPython.
 \end_inset 
 
 .
  This feature can also be toggled at any time with the 
 \family typewriter 
 %pdb
 \family default 
  magic command.
  This can be extremely useful in order to find the origin of subtle bugs,
  because 
 \family typewriter 
 pdb
 \family default 
  opens up at the point in your code which triggered the exception, and while
  your program is at this point `dead', all the data is still available and
  you can walk up and down the stack frame and understand the origin of the
  problem.
 \layout Standard
 
 Furthermore, you can use these debugging facilities both with the embedded
  IPython mode and without IPython at all.
  For an embedded shell (see sec.
  
 \begin_inset LatexCommand \ref{sec:embed}
 
 \end_inset 
 
 ), simply call the constructor with 
 \family typewriter 
 `-pdb'
 \family default 
  in the argument string and automatically 
 \family typewriter 
 pdb
 \family default 
  will be called if an uncaught exception is triggered by your code.
  
 \layout Standard
 
 For stand-alone use of the feature in your programs which do not use IPython
  at all, put the following lines toward the top of your `main' routine:
 \layout Standard
 \align left 
 
 \family typewriter 
 import sys,IPython.ultraTB 
 \newline 
 sys.excepthook = IPython.ultraTB.FormattedTB(mode=`Verbose', color_scheme=`Linux',
  call_pdb=1)
 \layout Standard
 
 The 
 \family typewriter 
 mode
 \family default 
  keyword can be either 
 \family typewriter 
 `Verbose'
 \family default 
  or 
 \family typewriter 
 `Plain'
 \family default 
 , giving either very detailed or normal tracebacks respectively.
  The 
 \family typewriter 
 color_scheme
 \family default 
  keyword can be one of 
 \family typewriter 
 `NoColor'
 \family default 
 , 
 \family typewriter 
 `Linux'
 \family default 
  (default) or 
 \family typewriter 
 `LightBG'
 \family default 
 .
  These are the same options which can be set in IPython with 
 \family typewriter 
 -colors
 \family default 
  and 
 \family typewriter 
 -xmode
 \family default 
 .
 \layout Standard
 
 This will give any of your programs detailed, colored tracebacks with automatic
  invocation of 
 \family typewriter 
 pdb
 \family default 
 .
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:syntax-extensions}
 
 \end_inset 
 
 Extensions for syntax processing
 \layout Standard
 
 This isn't for the faint of heart, because the potential for breaking things
  is quite high.
  But it can be a very powerful and useful feature.
  In a nutshell, you can redefine the way IPython processes the user input
  line to accept new, special extensions to the syntax without needing to
  change any of IPython's own code.
 \layout Standard
 
 In the 
 \family typewriter 
 IPython/Extensions
 \family default 
  directory you will find some examples supplied, which we will briefly describe
  now.
  These can be used `as is' (and both provide very useful functionality),
  or you can use them as a starting point for writing your own extensions.
 \layout Subsection
 
 Pasting of code starting with 
 \family typewriter 
 `>>> 
 \family default 
 ' or 
 \family typewriter 
 `...
  
 \family default 
 '
 \layout Standard
 
 In the python tutorial it is common to find code examples which have been
  taken from real python sessions.
  The problem with those is that all the lines begin with either 
 \family typewriter 
 `>>> 
 \family default 
 ' or 
 \family typewriter 
 `...
  
 \family default 
 ', which makes it impossible to paste them all at once.
  One must instead do a line by line manual copying, carefully removing the
  leading extraneous characters.
 \layout Standard
 
 This extension identifies those starting characters and removes them from
  the input automatically, so that one can paste multi-line examples directly
  into IPython, saving a lot of time.
  Please look at the file 
 \family typewriter 
 InterpreterPasteInput.py
 \family default 
  in the 
 \family typewriter 
 IPython/Extensions
 \family default 
  directory for details on how this is done.
 \layout Standard
 
 IPython comes with a special profile enabling this feature, called 
 \family typewriter 
 tutorial
 \family default 
 \emph on 
 .
 
 \emph default 
  Simply start IPython via 
 \family typewriter 
 `ipython\SpecialChar ~
 -p\SpecialChar ~
 tutorial'
 \family default 
  and the feature will be available.
  In a normal IPython session you can activate the feature by importing the
  corresponding module with:
 \newline 
 
 \family typewriter 
 In [1]: import IPython.Extensions.InterpreterPasteInput
 \layout Standard
 
 The following is a 'screenshot' of how things work when this extension is
  on, copying an example from the standard tutorial:
 \layout Standard
 
 
 \family typewriter 
 IPython profile: tutorial
 \newline 
 \SpecialChar ~
 
 \newline 
 *** Pasting of code with ">>>" or "..." has been enabled.
 \newline 
 \SpecialChar ~
 
 \newline 
 In [1]: >>> def fib2(n): # return Fibonacci series up to n
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  """Return a list containing the Fibonacci series up to n."""
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  result = []
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  a, b = 0, 1
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  while b < n:
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  result.append(b)\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  # see below
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  a, b = b, a+b
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...: ...\SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
  return result
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
  ...:
 \newline 
 \SpecialChar ~
 
 \newline 
 In [2]: fib2(10)
 \newline 
 Out[2]: [1, 1, 2, 3, 5, 8]
 \layout Standard
 
 Note that as currently written, this extension does 
 \emph on 
 not 
 \emph default 
 recognize IPython's prompts for pasting.
  Those are more complicated, since the user can change them very easily,
  they involve numbers and can vary in length.
  One could however extract all the relevant information from the IPython
  instance and build an appropriate regular expression.
  This is left as an exercise for the reader.
 \layout Subsection
 
 Input of physical quantities with units
 \layout Standard
 
 The module 
 \family typewriter 
 PhysicalQInput
 \family default 
  allows a simplified form of input for physical quantities with units.
  This file is meant to be used in conjunction with the 
 \family typewriter 
 PhysicalQInteractive
 \family default 
  module (in the same directory) and 
 \family typewriter 
 Physics.PhysicalQuantities
 \family default 
  from Konrad Hinsen's ScientificPython (
 \begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/hinsen/scientific.html}
 
 \end_inset 
 
 ).
 \layout Standard
 
 The 
 \family typewriter 
 Physics.PhysicalQuantities
 \family default 
  module defines 
 \family typewriter 
 PhysicalQuantity
 \family default 
  objects, but these must be declared as instances of a class.
  For example, to define 
 \family typewriter 
 v
 \family default 
  as a velocity of 3\SpecialChar ~
 m/s, normally you would write:
 \family typewriter 
 
 \newline 
 In [1]: v = PhysicalQuantity(3,'m/s')
 \layout Standard
 
 Using the 
 \family typewriter 
 PhysicalQ_Input
 \family default 
  extension this can be input instead as:
 \family typewriter 
 
 \newline 
 In [1]: v = 3 m/s
 \family default 
 
 \newline 
 which is much more convenient for interactive use (even though it is blatantly
  invalid Python syntax).
 \layout Standard
 
 The 
 \family typewriter 
 physics
 \family default 
  profile supplied with IPython (enabled via 
 \family typewriter 
 'ipython -p physics'
 \family default 
 ) uses these extensions, which you can also activate with:
 \layout Standard
 
 
 \family typewriter 
 from math import * # math MUST be imported BEFORE PhysicalQInteractive
 \newline 
 from IPython.Extensions.PhysicalQInteractive import *
 \newline 
 import IPython.Extensions.PhysicalQInput
 \layout Section
 
+
+\begin_inset LatexCommand \label{sec:IPython-as-shell}
+
+\end_inset 
+
 IPython as a system shell
 \layout Standard
 
 IPython ships with a special profile called 
 \family typewriter 
 pysh
 \family default 
 , which you can activate at the command line as 
 \family typewriter 
 `ipython -p pysh'
 \family default 
 .
  This loads 
 \family typewriter 
 InterpreterExec
 \family default 
 , along with some additional facilities and a prompt customized for filesystem
  navigation.
 \layout Standard
 
 Note that this does 
 \emph on 
 not
 \emph default 
  make IPython a full-fledged system shell.
  In particular, it has no job control, so if you type Ctrl-Z (under Unix),
  you'll suspend pysh itself, not the process you just started.
  
 \layout Standard
 
 What the shell profile allows you to do is to use the convenient and powerful
  syntax of Python to do quick scripting at the command line.
  Below we describe some of its features.
 \layout Subsection
 
 Aliases
 \layout Standard
 
 All of your 
 \family typewriter 
 $PATH
 \family default 
  has been loaded as IPython aliases, so you should be able to type any normal
  system command and have it executed.
  See 
 \family typewriter 
 %alias?
 \family default 
  and 
 \family typewriter 
 %unalias?
 \family default 
  for details on the alias facilities.
  See also 
 \family typewriter 
 %rehash?
 \family default 
  and 
 \family typewriter 
 %rehashx? 
 \family default 
 for details on the mechanism used to load 
 \family typewriter 
 $PATH
 \family default 
 .
 \layout Subsection
 
 Special syntax
 \layout Standard
 
 Any lines which begin with 
 \family typewriter 
 `~'
 \family default 
 , 
 \family typewriter 
 `/'
 \family default 
  and 
 \family typewriter 
 `.'
 \family default 
  will be executed as shell commands instead of as Python code.
  The special escapes below are also recognized.
  
 \family typewriter 
 !cmd
 \family default 
  is valid in single or multi-line input, all others are only valid in single-lin
 e input:
 \layout Description
 
 
 \family typewriter 
 !cmd
 \family default 
  pass `cmd' directly to the shell 
 \layout Description
 
 
 \family typewriter 
 !!cmd
 \family default 
  execute `cmd' and return output as a list (split on `
 \backslash 
 n') 
 \layout Description
 
 
 \family typewriter 
 $var=cmd
 \family default 
  capture output of cmd into var, as a string 
 \layout Description
 
 
 \family typewriter 
 $$var=cmd
 \family default 
  capture output of cmd into var, as a list (split on `
 \backslash 
 n')
 \layout Standard
 
 The 
 \family typewriter 
 $
 \family default 
 /
 \family typewriter 
 $$
 \family default 
  syntaxes make Python variables from system output, which you can later
  use for further scripting.
  The converse is also possible: when executing an alias or calling to the
  system via 
 \family typewriter 
 !
 \family default 
 /
 \family typewriter 
 !!
 \family default 
 , you can expand any python variable or expression by prepending it with
  
 \family typewriter 
 $
 \family default 
 .
  Full details of the allowed syntax can be found in Python's PEP 215.
 \layout Standard
 
 A few brief examples will illustrate these (note that the indentation below
  may be incorrectly displayed):
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|3> !ls *s.py 
 \newline 
 scopes.py strings.py
 \layout Standard
 
 ls is an internal alias, so there's no need to use 
 \family typewriter 
 !
 \family default 
 : 
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|4> ls *s.py 
 \newline 
 scopes.py* strings.py
 \layout Standard
 
 !!ls will return the output into a Python variable: 
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|5> !!ls *s.py 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 <5> ['scopes.py', 'strings.py'] 
 \newline 
 fperez[~/test]|6> print _5 
 \newline 
 ['scopes.py', 'strings.py']
 \layout Standard
 
 
 \family typewriter 
 $
 \family default 
  and 
 \family typewriter 
 $$
 \family default 
  allow direct capture to named variables: 
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|7> $astr = ls *s.py 
 \newline 
 fperez[~/test]|8> astr 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 <8> 'scopes.py
 \backslash 
 nstrings.py'
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|9> $$alist = ls *s.py 
 \newline 
 fperez[~/test]|10> alist 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 <10> ['scopes.py', 'strings.py']
 \layout Standard
 
 alist is now a normal python list you can loop over.
  Using 
 \family typewriter 
 $
 \family default 
  will expand back the python values when alias calls are made:
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|11> for f in alist: 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 |..> \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 print 'file',f, 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 |..> \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 wc -l $f 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 |..> 
 \newline 
 file scopes.py 13 scopes.py 
 \newline 
 file strings.py 4 strings.py
 \layout Standard
 
 Note that you may need to protect your variables with braces if you want
  to append strings to their names.
  To copy all files in alist to 
 \family typewriter 
 .bak
 \family default 
  extensions, you must use: 
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|12> for f in alist: 
 \newline 
 
 \begin_inset ERT
 status Collapsed
 
 \layout Standard
 
 \backslash 
 hspace*{0mm}
 \end_inset 
 
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 |..> \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 \SpecialChar ~
 cp $f ${f}.bak
 \layout Standard
 
 If you try using 
 \family typewriter 
 $f.bak
 \family default 
 , you'll get an AttributeError exception saying that your string object
  doesn't have a 
 \family typewriter 
 .bak
 \family default 
  attribute.
  This is because the 
 \family typewriter 
 $
 \family default 
  expansion mechanism allows you to expand full Python expressions: 
 \layout Standard
 
 
 \family typewriter 
 fperez[~/test]|13> echo "sys.platform is: $sys.platform" 
 \newline 
 sys.platform is: linux2
 \layout Standard
 
 IPython's input history handling is still active, which allows you to rerun
  a single block of multi-line input by simply using exec: 
 \newline 
 
 \family typewriter 
 fperez[~/test]|14> $$alist = ls *.eps 
 \newline 
 fperez[~/test]|15> exec _i11 
 \newline 
 file image2.eps 921 image2.eps 
 \newline 
 file image.eps 921 image.eps
 \layout Standard
 
 While these are new special-case syntaxes, they are designed to allow very
  efficient use of the shell with minimal typing.
  At an interactive shell prompt, conciseness of expression wins over readability.
 \layout Subsection
 
 Useful functions and modules
 \layout Standard
 
 The os, sys and shutil modules from the Python standard library are automaticall
 y loaded.
  Some additional functions, useful for shell usage, are listed below.
  You can request more help about them with `
 \family typewriter 
 ?
 \family default 
 '.
 \layout Description
 
 
 \family typewriter 
 shell
 \family default 
  - execute a command in the underlying system shell 
 \layout Description
 
 
 \family typewriter 
 system
 \family default 
  - like 
 \family typewriter 
 shell()
 \family default 
 , but return the exit status of the command
 \layout Description
 
 
 \family typewriter 
 sout
 \family default 
  - capture the output of a command as a string
 \layout Description
 
 
 \family typewriter 
 lout
 \family default 
  - capture the output of a command as a list (split on `
 \backslash 
 n')
 \layout Description
 
 
 \family typewriter 
 getoutputerror
 \family default 
  - capture (output,error) of a shell commandss
 \layout Standard
 
 
 \family typewriter 
 sout
 \family default 
 /
 \family typewriter 
 lout
 \family default 
  are the functional equivalents of 
 \family typewriter 
 $
 \family default 
 /
 \family typewriter 
 $$
 \family default 
 .
  They are provided to allow you to capture system output in the middle of
  true python code, function definitions, etc (where 
 \family typewriter 
 $
 \family default 
  and 
 \family typewriter 
 $$
 \family default 
  are invalid).
 \layout Subsection
 
 Directory management
 \layout Standard
 
 Since each command passed by pysh to the underlying system is executed in
  a subshell which exits immediately, you can NOT use !cd to navigate the
  filesystem.
 \layout Standard
 
 Pysh provides its own builtin 
 \family typewriter 
 `%cd
 \family default 
 ' magic command to move in the filesystem (the 
 \family typewriter 
 %
 \family default 
  is not required with automagic on).
  It also maintains a list of visited directories (use 
 \family typewriter 
 %dhist
 \family default 
  to see it) and allows direct switching to any of them.
  Type 
 \family typewriter 
 `cd?
 \family default 
 ' for more details.
 \layout Standard
 
 
 \family typewriter 
 %pushd
 \family default 
 , 
 \family typewriter 
 %popd
 \family default 
  and 
 \family typewriter 
 %dirs
 \family default 
  are provided for directory stack handling.
 \layout Subsection
 
 Prompt customization
 \layout Standard
 
 The supplied 
 \family typewriter 
 ipythonrc-pysh
 \family default 
  profile comes with an example of a very colored and detailed prompt, mainly
  to serve as an illustration.
  The valid escape sequences, besides color names, are:
 \layout Description
 
 
 \backslash 
 # - Prompt number.
 \layout Description
 
 
 \backslash 
 D - Dots, as many as there are digits in 
 \backslash 
 # (so they align).
 \layout Description
 
 
 \backslash 
 w - Current working directory (cwd).
 \layout Description
 
 
 \backslash 
 W - Basename of current working directory.
 \layout Description
 
 
 \backslash 
 X
 \emph on 
 N
 \emph default 
  - Where 
 \emph on 
 N
 \emph default 
 =0..5.
  N terms of the cwd, with $HOME written as ~.
 \layout Description
 
 
 \backslash 
 Y
 \emph on 
 N
 \emph default 
  - Where 
 \emph on 
 N
 \emph default 
 =0..5.
  Like X
 \emph on 
 N
 \emph default 
 , but if ~ is term 
 \emph on 
 N
 \emph default 
 +1 it's also shown.
 \layout Description
 
 
 \backslash 
 u - Username.
 \layout Description
 
 
 \backslash 
 H - Full hostname.
 \layout Description
 
 
 \backslash 
 h - Hostname up to first '.'
 \layout Description
 
 
 \backslash 
 $ - Root symbol ($ or #).
  
 \layout Description
 
 
 \backslash 
 t - Current time, in H:M:S format.
 \layout Description
 
 
 \backslash 
 v - IPython release version.
  
 \layout Description
 
 
 \backslash 
 n - Newline.
  
 \layout Description
 
 
 \backslash 
 r - Carriage return.
  
 \layout Description
 
 
 \backslash 
 
 \backslash 
  - An explicitly escaped '
 \backslash 
 '.
 \layout Standard
 
 You can configure your prompt colors using any ANSI color escape.
  Each color escape sets the color for any subsequent text, until another
  escape comes in and changes things.
  The valid color escapes are:
 \layout Description
 
 
 \backslash 
 C_Black
 \layout Description
 
 
 \backslash 
 C_Blue
 \layout Description
 
 
 \backslash 
 C_Brown
 \layout Description
 
 
 \backslash 
 C_Cyan
 \layout Description
 
 
 \backslash 
 C_DarkGray
 \layout Description
 
 
 \backslash 
 C_Green
 \layout Description
 
 
 \backslash 
 C_LightBlue
 \layout Description
 
 
 \backslash 
 C_LightCyan
 \layout Description
 
 
 \backslash 
 C_LightGray
 \layout Description
 
 
 \backslash 
 C_LightGreen
 \layout Description
 
 
 \backslash 
 C_LightPurple
 \layout Description
 
 
 \backslash 
 C_LightRed
 \layout Description
 
 
 \backslash 
 C_Purple
 \layout Description
 
 
 \backslash 
 C_Red
 \layout Description
 
 
 \backslash 
 C_White
 \layout Description
 
 
 \backslash 
 C_Yellow
 \layout Description
 
 
 \backslash 
 C_Normal Stop coloring, defaults to your terminal settings.
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:Threading-support}
 
 \end_inset 
 
 Threading support
 \layout Standard
 
 
 \series bold 
 WARNING: 
 \series default 
 The threading support is still somewhat experimental, and it has only seen
  reasonable testing under Linux.
  Threaded code is particularly tricky to debug, and it tends to show extremely
  platform-dependent behavior.
  Since I only have access to Linux machines, I will have to rely on user's
  experiences and assistance for this area of IPython to improve under other
  platforms.
 \layout Standard
 
 IPython, via the 
 \family typewriter 
 -gthread
 \family default 
  , 
 \family typewriter 
 -qthread
 \family default 
  and 
 \family typewriter 
 -wthread
 \family default 
  options (described in Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:threading-opts}
 
 \end_inset 
 
 ), can run in multithreaded mode to support pyGTK, Qt and WXPython applications
  respectively.
  These GUI toolkits need to control the python main loop of execution, so
  under a normal Python interpreter, starting a pyGTK, Qt or WXPython application
  will immediately freeze the shell.
  
 \layout Standard
 
 IPython, with one of these options (you can only use one at a time), separates
  the graphical loop and IPython's code execution run into different threads.
  This allows you to test interactively (with 
 \family typewriter 
 %run
 \family default 
 , for example) your GUI code without blocking.
 \layout Standard
 
 A nice mini-tutorial on using IPython along with the Qt Designer application
  is available at the SciPy wiki: 
 \begin_inset LatexCommand \htmlurl{http://www.scipy.org/wikis/topical_software/QtWithIPythonAndDesigner}
 
 \end_inset 
 
 .
 \layout Subsection
 
 Tk issues
 \layout Standard
 
 As indicated in Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:threading-opts}
 
 \end_inset 
 
 , a special 
 \family typewriter 
 -tk
 \family default 
  option is provided to try and allow Tk graphical applications to coexist
  interactively with WX, Qt or GTK ones.
  Whether this works at all, however, is very platform and configuration
  dependent.
  Please experiment with simple test cases before committing to using this
  combination of Tk and GTK/Qt/WX threading in a production environment.
 \layout Subsection
 
 Signals and Threads
 \layout Standard
 
 When any of the thread systems (GTK, Qt or WX) are active, either directly
  or via 
 \family typewriter 
 -pylab
 \family default 
  with a threaded backend, it is impossible to interrupt long-running Python
  code via 
 \family typewriter 
 Ctrl-C
 \family default 
 .
  IPython can not pass the KeyboardInterrupt exception (or the underlying
  
 \family typewriter 
 SIGINT
 \family default 
 ) across threads, so any long-running process started from IPython will
  run to completion, or will have to be killed via an external (OS-based)
  mechanism.
 \layout Standard
 
 To the best of my knowledge, this limitation is imposed by the Python interprete
 r itself, and it comes from the difficulty of writing portable signal/threaded
  code.
  If any user is an expert on this topic and can suggest a better solution,
  I would love to hear about it.
  In the IPython sources, look at the 
 \family typewriter 
 Shell.py
 \family default 
  module, and in particular at the 
 \family typewriter 
 runcode()
 \family default 
  method.
  
 \layout Subsection
 
 I/O pitfalls
 \layout Standard
 
 Be mindful that the Python interpreter switches between threads every 
 \begin_inset Formula $N$
 \end_inset 
 
  bytecodes, where the default value as of Python\SpecialChar ~
 2.3 is 
 \begin_inset Formula $N=100.$
 \end_inset 
 
  This value can be read by using the 
 \family typewriter 
 sys.getcheckinterval()
 \family default 
  function, and it can be reset via 
 \family typewriter 
 sys.setcheckinterval(
 \emph on 
 N
 \emph default 
 )
 \family default 
 .
  This switching of threads can cause subtly confusing effects if one of
  your threads is doing file I/O.
  In text mode, most systems only flush file buffers when they encounter
  a 
 \family typewriter 
 `
 \backslash 
 n'
 \family default 
 .
  An instruction as simple as
 \family typewriter 
 
 \newline 
 \SpecialChar ~
 \SpecialChar ~
 print >> filehandle, 
 \begin_inset Quotes eld
 \end_inset 
 
 hello world
 \begin_inset Quotes erd
 \end_inset 
 
 
 \family default 
 
 \newline 
 actually consists of several bytecodes, so it is possible that the newline
  does not reach your file before the next thread switch.
  Similarly, if you are writing to a file in binary mode, the file won't
  be flushed until the buffer fills, and your other thread may see apparently
  truncated files.
  
 \layout Standard
 
 For this reason, if you are using IPython's thread support and have (for
  example) a GUI application which will read data generated by files written
  to from the IPython thread, the safest approach is to open all of your
  files in unbuffered mode (the third argument to the 
 \family typewriter 
 file/open
 \family default 
  function is the buffering value):
 \newline 
 
 \family typewriter 
 \SpecialChar ~
 \SpecialChar ~
 filehandle = open(filename,mode,0)
 \layout Standard
 
 This is obviously a brute force way of avoiding race conditions with the
  file buffering.
  If you want to do it cleanly, and you have a resource which is being shared
  by the interactive IPython loop and your GUI thread, you should really
  handle it with thread locking and syncrhonization properties.
  The Python documentation discusses these.
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:interactive-demos}
 
 \end_inset 
 
 Interactive demos with IPython
 \layout Standard
 
 IPython ships with a basic system for running scripts interactively in sections,
  useful when presenting code to audiences.
  A few tags embedded in comments (so that the script remains valid Python
  code) divide a file into separate blocks, and the demo can be run one block
  at a time, with IPython printing (with syntax highlighting) the block before
  executing it, and returning to the interactive prompt after each block.
  The interactive namespace is updated after each block is run with the contents
  of the demo's namespace.
 \layout Standard
 
 This allows you to show a piece of code, run it and then execute interactively
  commands based on the variables just created.
  Once you want to continue, you simply execute the next block of the demo.
  The following listing shows the markup necessary for dividing a script
  into sections for execution as a demo.
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 codelist{examples/example-demo.py}
 \end_inset 
 
 
 \layout Standard
 
 In order to run a file as a demo, you must first make a 
 \family typewriter 
 Demo
 \family default 
  object out of it.
  If the file is named 
 \family typewriter 
 myscript.py
 \family default 
 , the following code will make a demo:
 \layout LyX-Code
 
 from IPython.demo import Demo
 \layout LyX-Code
 
 mydemo = Demo('myscript.py')
 \layout Standard
 
 This creates the 
 \family typewriter 
 mydemo
 \family default 
  object, whose blocks you run one at a time by simply calling the object
  with no arguments.
  If you have autocall active in IPython (the default), all you need to do
  is type
 \layout LyX-Code
 
 mydemo
 \layout Standard
 
 and IPython will call it, executing each block.
  Demo objects can be restarted, you can move forward or back skipping blocks,
  re-execute the last block, etc.
  Simply use the Tab key on a demo object to see its methods, and call 
 \family typewriter 
 `?'
 \family default 
  on them to see their docstrings for more usage details.
  In addition, the 
 \family typewriter 
 demo
 \family default 
  module itself contains a comprehensive docstring, which you can access
  via
 \layout LyX-Code
 
 from IPython import demo
 \layout LyX-Code
 
 demo?
 \layout Standard
 
 
 \series bold 
 Limitations:
 \series default 
  It is important to note that these demos are limited to fairly simple uses.
  In particular, you can 
 \emph on 
 not
 \emph default 
  put division marks in indented code (loops, if statements, function definitions
 , etc.) Supporting something like this would basically require tracking the
  internal execution state of the Python interpreter, so only top-level divisions
  are allowed.
  If you want to be able to open an IPython instance at an arbitrary point
  in a program, you can use IPython's embedding facilities, described in
  detail in Sec\SpecialChar \@.
 \SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:embed}
 
 \end_inset 
 
 .
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:matplotlib-support}
 
 \end_inset 
 
 Plotting with 
 \family typewriter 
 matplotlib
 \family default 
  
 \layout Standard
 
 The matplotlib library (
 \begin_inset LatexCommand \htmlurl[http://matplotlib.sourceforge.net]{http://matplotlib.sourceforge.net}
 
 \end_inset 
 
 ) provides high quality 2D plotting for Python.
  Matplotlib can produce plots on screen using a variety of GUI toolkits,
  including Tk, GTK and WXPython.
  It also provides a number of commands useful for scientific computing,
  all with a syntax compatible with that of the popular Matlab program.
 \layout Standard
 
 IPython accepts the special option 
 \family typewriter 
 -pylab
 \family default 
  (Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:cmd-line-opts}
 
 \end_inset 
 
 ).
  This configures it to support matplotlib, honoring the settings in the
  
 \family typewriter 
 .matplotlibrc
 \family default 
  file.
  IPython will detect the user's choice of matplotlib GUI backend, and automatica
 lly select the proper threading model to prevent blocking.
  It also sets matplotlib in interactive mode and modifies 
 \family typewriter 
 %run
 \family default 
  slightly, so that any matplotlib-based script can be executed using 
 \family typewriter 
 %run
 \family default 
  and the final 
 \family typewriter 
 show()
 \family default 
  command does not block the interactive shell.
 \layout Standard
 
 The 
 \family typewriter 
 -pylab
 \family default 
  option must be given first in order for IPython to configure its threading
  mode.
  However, you can still issue other options afterwards.
  This allows you to have a matplotlib-based environment customized with
  additional modules using the standard IPython profile mechanism (Sec.\SpecialChar ~
 
 \begin_inset LatexCommand \ref{sec:profiles}
 
 \end_inset 
 
 ): ``
 \family typewriter 
 ipython -pylab -p myprofile
 \family default 
 '' will load the profile defined in 
 \family typewriter 
 ipythonrc-myprofile
 \family default 
  after configuring matplotlib.
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:Gnuplot}
 
 \end_inset 
 
 Plotting with 
 \family typewriter 
 Gnuplot
 \layout Standard
 
 Through the magic extension system described in sec.
  
 \begin_inset LatexCommand \ref{sec:magic}
 
 \end_inset 
 
 , IPython incorporates a mechanism for conveniently interfacing with the
  Gnuplot system (
 \begin_inset LatexCommand \htmlurl{http://www.gnuplot.info}
 
 \end_inset 
 
 ).
  Gnuplot is a very complete 2D and 3D plotting package available for many
  operating systems and commonly included in modern Linux distributions.
  
 \layout Standard
 
 Besides having Gnuplot installed, this functionality requires the 
 \family typewriter 
 Gnuplot.py
 \family default 
  module for interfacing python with Gnuplot.
  It can be downloaded from: 
 \begin_inset LatexCommand \htmlurl{http://gnuplot-py.sourceforge.net}
 
 \end_inset 
 
 .
 \layout Subsection
 
 Proper Gnuplot configuration
 \layout Standard
 
 As of version 4.0, Gnuplot has excellent mouse and interactive keyboard support.
  However, as of 
 \family typewriter 
 Gnuplot.py
 \family default 
  version 1.7, a new option was added to communicate between Python and Gnuplot
  via FIFOs (pipes).
  This mechanism, while fast, also breaks the mouse system.
  You must therefore set the variable 
 \family typewriter 
 prefer_fifo_data
 \family default 
  to 
 \family typewriter 
 0
 \family default 
  in file 
 \family typewriter 
 gp_unix.py
 \family default 
  if you wish to keep the interactive mouse and keyboard features working
  properly (
 \family typewriter 
 prefer_inline_data
 \family default 
  also must be 
 \family typewriter 
 0
 \family default 
 , but this is the default so unless you've changed it manually you should
  be fine).
 \layout Standard
 
 'Out of the box', Gnuplot is configured with a rather poor set of size,
  color and linewidth choices which make the graphs fairly hard to read on
  modern high-resolution displays (although they work fine on old 640x480
  ones).
  Below is a section of my 
 \family typewriter 
 .Xdefaults
 \family default 
  file which I use for having a more convenient Gnuplot setup.
  Remember to load it by running 
 \family typewriter 
 `xrdb .Xdefaults`
 \family default 
 :
 \layout Standard
 
 
 \family typewriter 
 !******************************************************************
 \newline 
 ! gnuplot options
 \newline 
 ! modify this for a convenient window size
 \newline 
 gnuplot*geometry: 780x580
 \layout Standard
 
 
 \family typewriter 
 ! on-screen font (not for PostScript)
 \newline 
 gnuplot*font: -misc-fixed-bold-r-normal--15-120-100-100-c-90-iso8859-1
 \layout Standard
 
 
 \family typewriter 
 ! color options
 \newline 
 gnuplot*background: black
 \newline 
 gnuplot*textColor: white
 \newline 
 gnuplot*borderColor: white
 \newline 
 gnuplot*axisColor: white
 \newline 
 gnuplot*line1Color: red
 \newline 
 gnuplot*line2Color: green
 \newline 
 gnuplot*line3Color: blue
 \newline 
 gnuplot*line4Color: magenta
 \newline 
 gnuplot*line5Color: cyan
 \newline 
 gnuplot*line6Color: sienna
 \newline 
 gnuplot*line7Color: orange
 \newline 
 gnuplot*line8Color: coral
 \layout Standard
 
 
 \family typewriter 
 ! multiplicative factor for point styles
 \newline 
 gnuplot*pointsize: 2
 \layout Standard
 
 
 \family typewriter 
 ! line width options (in pixels)
 \newline 
 gnuplot*borderWidth: 2
 \newline 
 gnuplot*axisWidth: 2
 \newline 
 gnuplot*line1Width: 2
 \newline 
 gnuplot*line2Width: 2
 \newline 
 gnuplot*line3Width: 2
 \newline 
 gnuplot*line4Width: 2
 \newline 
 gnuplot*line5Width: 2
 \newline 
 gnuplot*line6Width: 2
 \newline 
 gnuplot*line7Width: 2
 \newline 
 gnuplot*line8Width: 2
 \layout Subsection
 
 The 
 \family typewriter 
 IPython.GnuplotRuntime
 \family default 
  module
 \layout Standard
 
 IPython includes a module called 
 \family typewriter 
 Gnuplot2.py
 \family default 
  which extends and improves the default 
 \family typewriter 
 Gnuplot
 \family default 
 .
 \family typewriter 
 py
 \family default 
  (which it still relies upon).
  For example, the new 
 \family typewriter 
 plot
 \family default 
  function adds several improvements to the original making it more convenient
  for interactive use, and 
 \family typewriter 
 hardcopy
 \family default 
  fixes a bug in the original which under some circumstances blocks the creation
  of PostScript output.
 \layout Standard
 
 For scripting use, 
 \family typewriter 
 GnuplotRuntime.py
 \family default 
  is provided, which wraps 
 \family typewriter 
 Gnuplot2.py
 \family default 
  and creates a series of global aliases.
  These make it easy to control Gnuplot plotting jobs through the Python
  language.
 \layout Standard
 
 Below is some example code which illustrates how to configure Gnuplot inside
  your own programs but have it available for further interactive use through
  an embedded IPython instance.
  Simply run this file at a system prompt.
  This file is provided as 
 \family typewriter 
 example-gnuplot.py
 \family default 
  in the examples directory:
 \layout Standard
 
 
 \begin_inset ERT
 status Open
 
 \layout Standard
 
 \backslash 
 codelist{examples/example-gnuplot.py}
 \end_inset 
 
 
 \layout Subsection
 
 The 
 \family typewriter 
 numeric
 \family default 
  profile: a scientific computing environment
 \layout Standard
 
 The 
 \family typewriter 
 numeric
 \family default 
  IPython profile, which you can activate with 
 \family typewriter 
 `ipython -p numeric
 \family default 
 ' will automatically load the IPython Gnuplot extensions (plus Numeric and
  other useful things for numerical computing), contained in the 
 \family typewriter 
 IPython.GnuplotInteractive
 \family default 
  module.
  This will create the globals 
 \family typewriter 
 Gnuplot 
 \family default 
 (an alias to the improved Gnuplot2 module), 
 \family typewriter 
 gp
 \family default 
  (a Gnuplot active instance), the new magic commands 
 \family typewriter 
 %gpc
 \family default 
  and 
 \family typewriter 
 %gp_set_instance
 \family default 
  and several other convenient globals.
  Type 
 \family typewriter 
 gphelp()
 \family default 
  for further details.
 \layout Standard
 
 This should turn IPython into a convenient environment for numerical computing,
  with all the functions in the NumPy library and the Gnuplot facilities
  for plotting.
  Further improvements can be obtained by loading the SciPy libraries for
  scientific computing, available at 
 \begin_inset LatexCommand \htmlurl{http://scipy.org}
 
 \end_inset 
 
 .
 \layout Standard
 
 If you are in the middle of a working session with numerical objects and
  need to plot them but you didn't start the 
 \family typewriter 
 numeric
 \family default 
  profile, you can load these extensions at any time by typing
 \newline 
 
 \family typewriter 
 from IPython.GnuplotInteractive import *
 \newline 
 
 \family default 
 at the IPython prompt.
  This will allow you to keep your objects intact and start using Gnuplot
  to view them.
 \layout Section
 
 Reporting bugs
 \layout Subsection*
 
 Automatic crash reports
 \layout Standard
 
 Ideally, IPython itself shouldn't crash.
  It will catch exceptions produced by you, but bugs in its internals will
  still crash it.
 \layout Standard
 
 In such a situation, IPython will leave a file named 
 \family typewriter 
 IPython_crash_report.txt
 \family default 
  in your IPYTHONDIR directory (that way if crashes happen several times
  it won't litter many directories, the post-mortem file is always located
  in the same place and new occurrences just overwrite the previous one).
  If you can mail this file to the developers (see sec.
  
 \begin_inset LatexCommand \ref{sec:credits}
 
 \end_inset 
 
  for names and addresses), it will help us 
 \emph on 
 a lot
 \emph default 
  in understanding the cause of the problem and fixing it sooner.
 \layout Subsection*
 
 The bug tracker
 \layout Standard
 
 IPython also has an online bug-tracker, located at 
 \begin_inset LatexCommand \htmlurl{http://www.scipy.net/roundup/ipython}
 
 \end_inset 
 
 .
  In addition to mailing the developers, it would be a good idea to file
  a bug report here.
  This will ensure that the issue is properly followed to conclusion.
 \layout Standard
 
 You can also use this bug tracker to file feature requests.
 \layout Section
 
 Brief history
 \layout Subsection
 
 Origins
 \layout Standard
 
 The current IPython system grew out of the following three projects:
 \layout List
 \labelwidthstring 00.00.0000
 
 ipython by Fernando Pérez.
  I was working on adding Mathematica-type prompts and a flexible configuration
  system (something better than 
 \family typewriter 
 $PYTHONSTARTUP
 \family default 
 ) to the standard Python interactive interpreter.
 \layout List
 \labelwidthstring 00.00.0000
 
 IPP by Janko Hauser.
  Very well organized, great usability.
  Had an old help system.
  IPP was used as the `container' code into which I added the functionality
  from ipython and LazyPython.
 \layout List
 \labelwidthstring 00.00.0000
 
 LazyPython by Nathan Gray.
  Simple but 
 \emph on 
 very
 \emph default 
  powerful.
  The quick syntax (auto parens, auto quotes) and verbose/colored tracebacks
  were all taken from here.
 \layout Standard
 
 When I found out (see sec.
  
 \begin_inset LatexCommand \ref{figgins}
 
 \end_inset 
 
 ) about IPP and LazyPython I tried to join all three into a unified system.
  I thought this could provide a very nice working environment, both for
  regular programming and scientific computing: shell-like features, IDL/Matlab
  numerics, Mathematica-type prompt history and great object introspection
  and help facilities.
  I think it worked reasonably well, though it was a lot more work than I
  had initially planned.
 \layout Subsection
 
 Current status
 \layout Standard
 
 The above listed features work, and quite well for the most part.
  But until a major internal restructuring is done (see below), only bug
  fixing will be done, no other features will be added (unless very minor
  and well localized in the cleaner parts of the code).
 \layout Standard
 
 IPython consists of some 12000 lines of pure python code, of which roughly
  50% are fairly clean.
  The other 50% are fragile, messy code which needs a massive restructuring
  before any further major work is done.
  Even the messy code is fairly well documented though, and most of the problems
  in the (non-existent) class design are well pointed to by a PyChecker run.
  So the rewriting work isn't that bad, it will just be time-consuming.
 \layout Subsection
 
 Future
 \layout Standard
 
 See the separate 
 \family typewriter 
 new_design
 \family default 
  document for details.
  Ultimately, I would like to see IPython become part of the standard Python
  distribution as a `big brother with batteries' to the standard Python interacti
 ve interpreter.
  But that will never happen with the current state of the code, so all contribut
 ions are welcome.
 \layout Section
 
 License
 \layout Standard
 
 IPython is released under the terms of the BSD license, whose general form
  can be found at: 
 \begin_inset LatexCommand \htmlurl{http://www.opensource.org/licenses/bsd-license.php}
 
 \end_inset 
 
 .
  The full text of the IPython license is reproduced below:
 \layout Quote
 
 
 \family typewriter 
 \size small 
 IPython is released under a BSD-type license.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez <[e-mail]>.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 Copyright (c) 2001 Janko Hauser <[e-mail]> and 
 \newline 
 Nathaniel Gray <[e-mail]>.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 All rights reserved.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 Redistribution and use in source and binary forms, with or without modification,
  are permitted provided that the following conditions are met:
 \layout Quote
 
 
 \family typewriter 
 \size small 
 a.
  Redistributions of source code must retain the above copyright notice,
  this list of conditions and the following disclaimer.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 b.
  Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 c.
  Neither the name of the copyright holders nor the names of any contributors
  to this software may be used to endorse or promote products derived from
  this software without specific prior written permission.
 \layout Quote
 
 
 \family typewriter 
 \size small 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  PURPOSE ARE DISCLAIMED.
  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
 \layout Standard
 
 Individual authors are the holders of the copyright for their code and are
  listed in each file.
 \layout Standard
 
 Some files (
 \family typewriter 
 DPyGetOpt.py
 \family default 
 , for example) may be licensed under different conditions.
  Ultimately each file indicates clearly the conditions under which its author/au
 thors have decided to publish the code.
 \layout Standard
 
 Versions of IPython up to and including 0.6.3 were released under the GNU
  Lesser General Public License (LGPL), available at 
 \begin_inset LatexCommand \htmlurl{http://www.gnu.org/copyleft/lesser.html}
 
 \end_inset 
 
 .
 \layout Section
 
 
 \begin_inset LatexCommand \label{sec:credits}
 
 \end_inset 
 
 Credits
 \layout Standard
 
 IPython is mainly developed by Fernando Pérez 
 \family typewriter 
 <[e-mail]>
 \family default 
 , but the project was born from mixing in Fernando's code with the IPP project
  by Janko Hauser 
 \family typewriter 
 <jhauser-AT-zscout.de>
 \family default 
  and LazyPython by Nathan Gray 
 \family typewriter 
 <n8gray-AT-caltech.edu>
 \family default 
 .
  For all IPython-related requests, please contact Fernando.
  
 \layout Standard
 
 As of late 2005, the following developers have joined the core team:
 \layout List
 \labelwidthstring 00.00.0000
 
 Robert\SpecialChar ~
 Kern 
 \family typewriter 
 <rkern-AT-enthought.com>
 \family default 
 : co-mentored the 2005 Google Summer of Code project to develop python interacti
 ve notebooks (XML documents) and graphical interface.
  This project was awarded to the students Tzanko Matev 
 \family typewriter 
 <tsanko-AT-gmail.com>
 \family default 
  and Toni Alatalo 
 \family typewriter 
 <antont-AT-an.org>
 \layout List
 \labelwidthstring 00.00.0000
 
 Brian\SpecialChar ~
 Granger 
 \family typewriter 
 <bgranger-AT-scu.edu>
 \family default 
 : extending IPython to allow support for interactive parallel computing.
 \layout Standard
 
 User or development help should be requested via the IPython mailing lists:
 \layout Description
 
 User\SpecialChar ~
 list: 
 \begin_inset LatexCommand \htmlurl{http://scipy.net/mailman/listinfo/ipython-user}
 
 \end_inset 
 
 
 \layout Description
 
 Developer's\SpecialChar ~
 list: 
 \begin_inset LatexCommand \htmlurl{http://scipy.net/mailman/listinfo/ipython-dev}
 
 \end_inset 
 
 
 \layout Standard
 
 The IPython project is also very grateful to
 \begin_inset Foot
 collapsed true
 
 \layout Standard
 
 I've mangled email addresses to reduce spam, since the IPython manuals can
  be accessed online.
 \end_inset 
 
 :
 \layout Standard
 
 Bill Bumgarner 
 \family typewriter 
 <bbum-AT-friday.com>
 \family default 
 : for providing the DPyGetOpt module which gives very powerful and convenient
  handling of command-line options (light years ahead of what Python 2.1.1's
  getopt module does).
 \layout Standard
 
 Ka-Ping Yee 
 \family typewriter 
 <ping-AT-lfw.org>
 \family default 
 : for providing the Itpl module for convenient and powerful string interpolation
  with a much nicer syntax than formatting through the '%' operator.
 \layout Standard
 
 Arnd Bäcker 
 \family typewriter 
 <baecker-AT-physik.tu-dresden.de>
 \family default 
 : for his many very useful suggestions and comments, and lots of help with
  testing and documentation checking.
  Many of IPython's newer features are a result of discussions with him (bugs
  are still my fault, not his).
 \layout Standard
 
 Obviously Guido van\SpecialChar ~
 Rossum and the whole Python development team, that goes
  without saying.
 \layout Standard
 
 IPython's website is generously hosted at 
 \begin_inset LatexCommand \htmlurl{http://ipython.scipy.org}
 
 \end_inset 
 
  by Enthought (
 \begin_inset LatexCommand \htmlurl{http://www.enthought.com}
 
 \end_inset 
 
 ).
  I am very grateful to them and all of the SciPy team for their contribution.
 \layout Standard
 
 
 \begin_inset LatexCommand \label{figgins}
 
 \end_inset 
 
 Fernando would also like to thank Stephen Figgins 
 \family typewriter 
 <fig-AT-monitor.net>
 \family default 
 , an O'Reilly Python editor.
  His Oct/11/2001 article about IPP and LazyPython, was what got this project
  started.
  You can read it at: 
 \begin_inset LatexCommand \htmlurl{http://www.onlamp.com/pub/a/python/2001/10/11/pythonnews.html}
 
 \end_inset 
 
 .
 \layout Standard
 
 And last but not least, all the kind IPython users who have emailed new
  code, bug reports, fixes, comments and ideas.
  A brief list follows, please let me know if I have ommitted your name by
  accident: 
 \layout List
 \labelwidthstring 00.00.0000
 
 Jack\SpecialChar ~
 Moffit 
 \family typewriter 
 <jack-AT-xiph.org>
 \family default 
  Bug fixes, including the infamous color problem.
  This bug alone caused many lost hours and frustration, many thanks to him
  for the fix.
  I've always been a fan of Ogg & friends, now I have one more reason to
  like these folks.
 \newline 
 Jack is also contributing with Debian packaging and many other things.
 \layout List
 \labelwidthstring 00.00.0000
 
 Alexander\SpecialChar ~
 Schmolck 
 \family typewriter 
 <a.schmolck-AT-gmx.net> 
 \family default 
 Emacs work, bug reports, bug fixes, ideas, lots more.
  The ipython.el mode for (X)Emacs is Alex's code, providing full support
  for IPython under (X)Emacs.
 \layout List
 \labelwidthstring 00.00.0000
 
 Andrea\SpecialChar ~
 Riciputi 
 \family typewriter 
 <andrea.riciputi-AT-libero.it>
 \family default 
  Mac OSX information, Fink package management.
 \layout List
 \labelwidthstring 00.00.0000
 
 Gary\SpecialChar ~
 Bishop 
 \family typewriter 
 <gb-AT-cs.unc.edu>
 \family default 
  Bug reports, and patches to work around the exception handling idiosyncracies
  of WxPython.
  Readline and color support for Windows.
 \layout List
 \labelwidthstring 00.00.0000
 
 Jeffrey\SpecialChar ~
 Collins 
 \family typewriter 
 <Jeff.Collins-AT-vexcel.com>
 \family default 
  Bug reports.
  Much improved readline support, including fixes for Python 2.3.
 \layout List
 \labelwidthstring 00.00.0000
 
 Dryice\SpecialChar ~
 Liu 
 \family typewriter 
 <dryice-AT-liu.com.cn>
 \family default 
  FreeBSD port.
 \layout List
 \labelwidthstring 00.00.0000
 
 Mike\SpecialChar ~
 Heeter 
 \family typewriter 
 <korora-AT-SDF.LONESTAR.ORG>
 \layout List
 \labelwidthstring 00.00.0000
 
 Christopher\SpecialChar ~
 Hart 
 \family typewriter 
 <hart-AT-caltech.edu>
 \family default 
  PDB integration.
 \layout List
 \labelwidthstring 00.00.0000
 
 Milan\SpecialChar ~
 Zamazal 
 \family typewriter 
 <pdm-AT-zamazal.org>
 \family default 
  Emacs info.
 \layout List
 \labelwidthstring 00.00.0000
 
 Philip\SpecialChar ~
 Hisley 
 \family typewriter 
 <compsys-AT-starpower.net>
 \layout List
 \labelwidthstring 00.00.0000
 
 Holger\SpecialChar ~
 Krekel 
 \family typewriter 
 <pyth-AT-devel.trillke.net>
 \family default 
  Tab completion, lots more.
 \layout List
 \labelwidthstring 00.00.0000
 
 Robin\SpecialChar ~
 Siebler 
 \family typewriter 
 <robinsiebler-AT-starband.net>
 \layout List
 \labelwidthstring 00.00.0000
 
 Ralf\SpecialChar ~
 Ahlbrink
 \family typewriter 
  <ralf_ahlbrink-AT-web.de>
 \layout List
 \labelwidthstring 00.00.0000
 
 Thorsten\SpecialChar ~
 Kampe 
 \family typewriter 
 <thorsten-AT-thorstenkampe.de>
 \layout List
 \labelwidthstring 00.00.0000
 
 Fredrik\SpecialChar ~
 Kant 
 \family typewriter 
 <fredrik.kant-AT-front.com>
 \family default 
  Windows setup.
 \layout List
 \labelwidthstring 00.00.0000
 
 Syver\SpecialChar ~
 Enstad 
 \family typewriter 
 <syver-en-AT-online.no>
 \family default 
  Windows setup.
 \layout List
 \labelwidthstring 00.00.0000
 
 Richard 
 \family typewriter 
 <rxe-AT-renre-europe.com>
 \family default 
  Global embedding.
 \layout List
 \labelwidthstring 00.00.0000
 
 Hayden\SpecialChar ~
 Callow 
 \family typewriter 
 <h.callow-AT-elec.canterbury.ac.nz>
 \family default 
  Gnuplot.py 1.6 compatibility.
 \layout List
 \labelwidthstring 00.00.0000
 
 Leonardo\SpecialChar ~
 Santagada 
 \family typewriter 
 <retype-AT-terra.com.br>
 \family default 
  Fixes for Windows installation.
 \layout List
 \labelwidthstring 00.00.0000
 
 Christopher\SpecialChar ~
 Armstrong 
 \family typewriter 
 <radix-AT-twistedmatrix.com>
 \family default 
  Bugfixes.
 \layout List
 \labelwidthstring 00.00.0000
 
 Francois\SpecialChar ~
 Pinard 
 \family typewriter 
 <pinard-AT-iro.umontreal.ca>
 \family default 
  Code and documentation fixes.
 \layout List
 \labelwidthstring 00.00.0000
 
 Cory\SpecialChar ~
 Dodt 
 \family typewriter 
 <cdodt-AT-fcoe.k12.ca.us>
 \family default 
  Bug reports and Windows ideas.
  Patches for Windows installer.
 \layout List
 \labelwidthstring 00.00.0000
 
 Olivier\SpecialChar ~
 Aubert 
 \family typewriter 
 <oaubert-AT-bat710.univ-lyon1.fr>
 \family default 
  New magics.
 \layout List
 \labelwidthstring 00.00.0000
 
 King\SpecialChar ~
 C.\SpecialChar ~
 Shu 
 \family typewriter 
 <kingshu-AT-myrealbox.com>
 \family default 
  Autoindent patch.
 \layout List
 \labelwidthstring 00.00.0000
 
 Chris\SpecialChar ~
 Drexler 
 \family typewriter 
 <chris-AT-ac-drexler.de>
 \family default 
  Readline packages for Win32/CygWin.
 \layout List
 \labelwidthstring 00.00.0000
 
 Gustavo\SpecialChar ~
 Córdova\SpecialChar ~
 Avila 
 \family typewriter 
 <gcordova-AT-sismex.com>
 \family default 
  EvalDict code for nice, lightweight string interpolation.
 \layout List
 \labelwidthstring 00.00.0000
 
 Kasper\SpecialChar ~
 Souren 
 \family typewriter 
 <Kasper.Souren-AT-ircam.fr>
 \family default 
  Bug reports, ideas.
 \layout List
 \labelwidthstring 00.00.0000
 
 Gever\SpecialChar ~
 Tulley 
 \family typewriter 
 <gever-AT-helium.com>
 \family default 
  Code contributions.
 \layout List
 \labelwidthstring 00.00.0000
 
 Ralf\SpecialChar ~
 Schmitt 
 \family typewriter 
 <ralf-AT-brainbot.com>
 \family default 
  Bug reports & fixes.
 \layout List
 \labelwidthstring 00.00.0000
 
 Oliver\SpecialChar ~
 Sander 
 \family typewriter 
 <osander-AT-gmx.de>
 \family default 
  Bug reports.
 \layout List
 \labelwidthstring 00.00.0000
 
 Rod\SpecialChar ~
 Holland 
 \family typewriter 
 <rhh-AT-structurelabs.com>
 \family default 
  Bug reports and fixes to logging module.
 \layout List
 \labelwidthstring 00.00.0000
 
 Daniel\SpecialChar ~
 'Dang'\SpecialChar ~
 Griffith 
 \family typewriter 
 <pythondev-dang-AT-lazytwinacres.net>
 \family default 
  Fixes, enhancement suggestions for system shell use.
 \layout List
 \labelwidthstring 00.00.0000
 
 Viktor\SpecialChar ~
 Ransmayr 
 \family typewriter 
 <viktor.ransmayr-AT-t-online.de>
 \family default 
  Tests and reports on Windows installation issues.
  Contributed a true Windows binary installer.
 \layout List
 \labelwidthstring 00.00.0000
 
 Mike\SpecialChar ~
 Salib 
 \family typewriter 
 <msalib-AT-mit.edu>
 \family default 
  Help fixing a subtle bug related to traceback printing.
 \layout List
 \labelwidthstring 00.00.0000
 
 W.J.\SpecialChar ~
 van\SpecialChar ~
 der\SpecialChar ~
 Laan 
 \family typewriter 
 <gnufnork-AT-hetdigitalegat.nl>
 \family default 
  Bash-like prompt specials.
 \layout List
 \labelwidthstring 00.00.0000
 
 Ville\SpecialChar ~
 Vainio 
 \family typewriter 
 <vivainio-AT-kolumbus.fi>
 \family default 
  Bugfixes and suggestions.
  Excellent patches for many new features.
 \layout List
 \labelwidthstring 00.00.0000
 
 Antoon\SpecialChar ~
 Pardon 
 \family typewriter 
 <Antoon.Pardon-AT-rece.vub.ac.be>
 \family default 
  Critical fix for the multithreaded IPython.
 \layout List
 \labelwidthstring 00.00.0000
 
 John\SpecialChar ~
 Hunter 
 \family typewriter 
 <jdhunter-AT-nitace.bsd.uchicago.edu>
 \family default 
  Matplotlib author, helped with all the development of support for matplotlib
  in IPyhton, including making necessary changes to matplotlib itself.
 \layout List
 \labelwidthstring 00.00.0000
 
 Matthew\SpecialChar ~
 Arnison 
 \family typewriter 
 <maffew-AT-cat.org.au>
 \family default 
  Bug reports, `
 \family typewriter 
 %run -d
 \family default 
 ' idea.
 \layout List
 \labelwidthstring 00.00.0000
 
 Prabhu\SpecialChar ~
 Ramachandran 
 \family typewriter 
 <prabhu_r-AT-users.sourceforge.net>
 \family default 
  Help with (X)Emacs support, threading patches, ideas...
 \layout List
 \labelwidthstring 00.00.0000
 
 Norbert\SpecialChar ~
 Tretkowski 
 \family typewriter 
 <tretkowski-AT-inittab.de>
 \family default 
  help with Debian packaging and distribution.
 \layout List
 \labelwidthstring 00.00.0000
 
 George\SpecialChar ~
 Sakkis <
 \family typewriter 
 gsakkis-AT-eden.rutgers.edu>
 \family default 
  New matcher for tab-completing named arguments of user-defined functions.
 \layout List
 \labelwidthstring 00.00.0000
 
 J�rgen\SpecialChar ~
 Stenarson 
 \family typewriter 
 <jorgen.stenarson-AT-bostream.nu>
 \family default 
  Wildcard support implementation for searching namespaces.
 \layout List
 \labelwidthstring 00.00.0000
 
 Vivian\SpecialChar ~
 De\SpecialChar ~
 Smedt 
 \family typewriter 
 <vivian-AT-vdesmedt.com>
 \family default 
  Debugger enhancements, so that when pdb is activated from within IPython,
  coloring, tab completion and other features continue to work seamlessly.
 \layout List
 \labelwidthstring 00.00.0000
 
 Scott\SpecialChar ~
 Tsai 
 \family typewriter 
 <scottt958-AT-yahoo.com.tw>
 \family default 
  Support for automatic editor invocation on syntax errors (see 
 \begin_inset LatexCommand \htmlurl{http://www.scipy.net/roundup/ipython/issue36}
 
 \end_inset 
 
 ).
 \layout List
 \labelwidthstring 00.00.0000
 
 Alexander\SpecialChar ~
 Belchenko 
 \family typewriter 
 <bialix-AT-ukr.net>
 \family default 
  Improvements for win32 paging system.
 \the_end