Merge in all development done in bzr since February 16 2008.

At that time, a clean bzr branch was started from the SVN tree, but
without SVN history.  That SVN history has now been used as the basis
of this branch, and the development done on the history-less BZR
branch has been added and is the content of this merge.  

This branch will be the new official main line of development in
Launchpad (equivalent to the old SVN trunk).

.checkeol

@@ -0,0 +1,2 b''
+[LF]
+*.py

IPython/Extensions/ipy_autoreload.py

@@ -0,0 +1,244 b''
+"""
+IPython extension: autoreload modules before executing the next line
+
+Try:: 
+
+    %autoreload?
+
+for documentation.
+"""
+
+# Pauli Virtanen <[e-mail]>, 2008.
+# Thomas Heller, 2000.
+#
+# This IPython module is written by Pauli Virtanen, based on the autoreload
+# code by Thomas Heller.
+
+#------------------------------------------------------------------------------
+# Autoreload functionality
+#------------------------------------------------------------------------------
+
+import time, os, threading, sys, types, imp, inspect, traceback, atexit
+
+def _get_compiled_ext():
+    """Official way to get the extension of compiled files (.pyc or .pyo)"""
+    for ext, mode, typ in imp.get_suffixes():
+        if typ == imp.PY_COMPILED:
+            return ext
+
+PY_COMPILED_EXT = _get_compiled_ext()
+
+class ModuleReloader(object):
+    skipped = {}
+    """Modules that failed to reload: {module: mtime-on-failed-reload, ...}"""
+    
+    modules = {}
+    """Modules specially marked as autoreloadable."""
+
+    skip_modules = {}
+    """Modules specially marked as not autoreloadable."""
+
+    check_all = True
+    """Autoreload all modules, not just those listed in 'modules'"""
+    
+    def check(self, check_all=False):
+        """Check whether some modules need to be reloaded."""
+        
+        if check_all or self.check_all:
+            modules = sys.modules.keys()
+        else:
+            modules = self.modules.keys()
+        
+        for modname in modules:
+            m = sys.modules.get(modname, None)
+
+            if modname in self.skip_modules:
+                continue
+            
+            if not hasattr(m, '__file__'):
+                continue
+            
+            if m.__name__ == '__main__':
+                # we cannot reload(__main__)
+                continue
+            
+            filename = m.__file__
+            dirname = os.path.dirname(filename)
+            path, ext = os.path.splitext(filename)
+            
+            if ext.lower() == '.py':
+                ext = PY_COMPILED_EXT
+                filename = os.path.join(dirname, path + PY_COMPILED_EXT)
+            
+            if ext != PY_COMPILED_EXT:
+                continue
+            
+            try:
+                pymtime = os.stat(filename[:-1]).st_mtime
+                if pymtime <= os.stat(filename).st_mtime:
+                    continue
+                if self.skipped.get(filename[:-1], None) == pymtime:
+                    continue
+            except OSError:
+                continue
+            
+            try:
+                superreload(m)
+                if filename[:-1] in self.skipped:
+                    del self.skipped[filename[:-1]]
+            except:
+                self.skipped[filename[:-1]] = pymtime
+
+def update_function(old, new, attrnames):
+    for name in attrnames:
+        setattr(old, name, getattr(new, name))
+
+def superreload(module, reload=reload):
+    """Enhanced version of the builtin reload function.
+    
+    superreload replaces the class dictionary of every top-level
+    class in the module with the new one automatically,
+    as well as every function's code object.
+    
+    """
+
+    module = reload(module)
+    
+    # iterate over all objects and update them
+    count = 0
+    for name, new_obj in module.__dict__.items():
+        key = (module.__name__, name)
+        if _old_objects.has_key(key):
+            for old_obj in _old_objects[key]:
+                if type(new_obj) == types.ClassType:
+                    old_obj.__dict__.update(new_obj.__dict__)
+                    count += 1
+                elif type(new_obj) == types.FunctionType:
+                    update_function(old_obj,
+                           new_obj,
+                           "func_code func_defaults func_doc".split())
+                    count += 1
+                elif type(new_obj) == types.MethodType:
+                    update_function(old_obj.im_func,
+                           new_obj.im_func,
+                           "func_code func_defaults func_doc".split())
+                    count += 1
+    
+    return module
+
+reloader = ModuleReloader()
+
+#------------------------------------------------------------------------------
+# IPython monkey-patching
+#------------------------------------------------------------------------------
+
+import IPython.iplib
+
+autoreload_enabled = False
+
+def runcode_hook(self):
+    if not autoreload_enabled:
+        raise IPython.ipapi.TryNext
+    try:
+        reloader.check()
+    except:
+        pass
+
+
+def enable_autoreload():
+    global autoreload_enabled
+    autoreload_enabled = True
+    
+
+def disable_autoreload():
+    global autoreload_enabled
+    autoreload_enabled = False
+    
+#------------------------------------------------------------------------------
+# IPython connectivity
+#------------------------------------------------------------------------------
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def autoreload_f(self, parameter_s=''):
+    r""" %autoreload => Reload modules automatically
+
+    %autoreload
+    Reload all modules (except thoses excluded by %aimport) automatically now.
+
+    %autoreload 1
+    Reload all modules imported with %aimport every time before executing
+    the Python code typed.
+
+    %autoreload 2
+    Reload all modules (except thoses excluded by %aimport) every time
+    before executing the Python code typed.
+
+    Reloading Python modules in a reliable way is in general
+    difficult, and unexpected things may occur. Some of the common
+    caveats relevant for 'autoreload' are:
+
+    - Modules are not reloaded in any specific order, and no dependency
+      analysis is done. For example, modules with 'from xxx import foo'
+      retain old versions of 'foo' when 'xxx' is autoreloaded.
+    - Functions or objects imported from the autoreloaded module to
+      the interactive namespace are not updated.
+    - C extension modules cannot be reloaded, and so cannot be
+      autoreloaded.
+    """
+    if parameter_s == '':
+        reloader.check(True)
+    elif parameter_s == '0':
+        disable_autoreload()
+    elif parameter_s == '1':
+        reloader.check_all = False
+        enable_autoreload()
+    elif parameter_s == '2':
+        reloader.check_all = True
+        enable_autoreload()
+
+def aimport_f(self, parameter_s=''):
+    """%aimport => Import modules for automatic reloading.
+
+    %aimport
+    List modules to automatically import and not to import.
+
+    %aimport foo
+    Import module 'foo' and mark it to be autoreloaded for %autoreload 1
+
+    %aimport -foo
+    Mark module 'foo' to not be autoreloaded for %autoreload 1
+
+    """
+    
+    modname = parameter_s
+    if not modname:
+        to_reload = reloader.modules.keys()
+        to_reload.sort()
+        to_skip = reloader.skip_modules.keys()
+        to_skip.sort()
+        if reloader.check_all:
+            print "Modules to reload:\nall-expect-skipped"
+        else:
+            print "Modules to reload:\n%s" % ' '.join(to_reload)
+        print "\nModules to skip:\n%s" % ' '.join(to_skip)
+    elif modname.startswith('-'):
+        modname = modname[1:]
+        try: del reloader.modules[modname]
+        except KeyError: pass
+        reloader.skip_modules[modname] = True
+    else:
+        try: del reloader.skip_modules[modname]
+        except KeyError: pass
+        reloader.modules[modname] = True
+
+        mod = __import__(modname)
+        ip.to_user_ns({modname: mod})
+
+def init():
+    ip.expose_magic('autoreload', autoreload_f)
+    ip.expose_magic('aimport', aimport_f)
+    ip.set_hook('pre_runcode_hook', runcode_hook)
+    
+init()
  No newline at end of file

IPython/Extensions/ipy_bzr.py

@@ -0,0 +1,343 b''
+""" Extension for bzr command tab completer. Supports comlpeting commands and options
+
+Unlike the core IPython, you should note that this extension is under GPL, not BSD.
+
+Based on "shell" bzr plugin by Aaron Bentley, license is below. The IPython additions
+are at the bottom of the file, the rest is left untouched.
+
+Must be loaded with ip.load('ipy_bzr') 
+
+""" 
+
+# Copyright (C) 2004, 2005 Aaron Bentley
+# <[e-mail]>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import cmd
+from itertools import chain
+import os
+import shlex
+import stat
+import string
+import sys
+
+from bzrlib import osutils
+from bzrlib.branch import Branch
+from bzrlib.config import config_dir, ensure_config_dir_exists
+from bzrlib.commands import get_cmd_object, get_all_cmds, get_alias
+from bzrlib.errors import BzrError
+from bzrlib.workingtree import WorkingTree
+import bzrlib.plugin
+
+
+SHELL_BLACKLIST = set(['rm', 'ls'])
+COMPLETION_BLACKLIST = set(['shell'])
+
+
+class BlackListedCommand(BzrError):
+    def __init__(self, command):
+        BzrError.__init__(self, "The command %s is blacklisted for shell use" %
+                          command)
+
+
+class CompletionContext(object):
+    def __init__(self, text, command=None, prev_opt=None, arg_pos=None):
+        self.text = text
+        self.command = command
+        self.prev_opt = prev_opt
+        self.arg_pos = None
+
+    def get_completions(self):
+        try:
+            return self.get_completions_or_raise()
+        except Exception, e:
+            print e, type(e)
+            return []
+
+    def get_option_completions(self):
+        try:
+            command_obj = get_cmd_object(self.command)
+        except BzrError:
+            return []
+        opts = [o+" " for o in iter_opt_completions(command_obj)]
+        return list(filter_completions(opts, self.text))
+
+    def get_completions_or_raise(self):
+        if self.command is None:
+            if '/' in self.text:
+                iter = iter_executables(self.text)
+            else:
+                iter = (c+" " for c in iter_command_names() if
+                        c not in COMPLETION_BLACKLIST)
+            return list(filter_completions(iter, self.text))
+        if self.prev_opt is None:
+            completions = self.get_option_completions()
+            if self.command == "cd":
+                iter = iter_dir_completions(self.text)
+                completions.extend(list(filter_completions(iter, self.text)))
+            else:
+                iter = iter_file_completions(self.text)
+                completions.extend(filter_completions(iter, self.text))
+            return completions
+
+
+class PromptCmd(cmd.Cmd):
+
+    def __init__(self):
+        cmd.Cmd.__init__(self)
+        self.prompt = "bzr> "
+        try:
+            self.tree = WorkingTree.open_containing('.')[0]
+        except:
+            self.tree = None
+        self.set_title()
+        self.set_prompt()
+        self.identchars += '-'
+        ensure_config_dir_exists()
+        self.history_file = osutils.pathjoin(config_dir(), 'shell-history')
+        readline.set_completer_delims(string.whitespace)
+        if os.access(self.history_file, os.R_OK) and \
+            os.path.isfile(self.history_file):
+            readline.read_history_file(self.history_file)
+        self.cwd = os.getcwd()
+
+    def write_history(self):
+        readline.write_history_file(self.history_file)
+
+    def do_quit(self, args):
+        self.write_history()
+        raise StopIteration
+
+    def do_exit(self, args):
+        self.do_quit(args)
+
+    def do_EOF(self, args):
+        print
+        self.do_quit(args)
+
+    def postcmd(self, line, bar):
+        self.set_title()
+        self.set_prompt()
+
+    def set_prompt(self):
+        if self.tree is not None:
+            try:
+                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(),
+                               self.tree.relpath('.'))
+                prompt = " %s:%d/%s" % prompt_data
+            except:
+                prompt = ""
+        else:
+            prompt = ""
+        self.prompt = "bzr%s> " % prompt
+
+    def set_title(self, command=None):
+        try:
+            b = Branch.open_containing('.')[0]
+            version = "%s:%d" % (b.nick, b.revno())
+        except:
+            version = "[no version]"
+        if command is None:
+            command = ""
+        sys.stdout.write(terminal.term_title("bzr %s %s" % (command, version)))
+
+    def do_cd(self, line):
+        if line == "":
+            line = "~"
+        line = os.path.expanduser(line)
+        if os.path.isabs(line):
+            newcwd = line
+        else:
+            newcwd = self.cwd+'/'+line
+        newcwd = os.path.normpath(newcwd)
+        try:
+            os.chdir(newcwd)
+            self.cwd = newcwd
+        except Exception, e:
+            print e
+        try:
+            self.tree = WorkingTree.open_containing(".")[0]
+        except:
+            self.tree = None
+
+    def do_help(self, line):
+        self.default("help "+line)
+
+    def default(self, line):
+        args = shlex.split(line)
+        alias_args = get_alias(args[0])
+        if alias_args is not None:
+            args[0] = alias_args.pop(0)
+
+        commandname = args.pop(0)
+        for char in ('|', '<', '>'):
+            commandname = commandname.split(char)[0]
+        if commandname[-1] in ('|', '<', '>'):
+            commandname = commandname[:-1]
+        try:
+            if commandname in SHELL_BLACKLIST:
+                raise BlackListedCommand(commandname)
+            cmd_obj = get_cmd_object(commandname)
+        except (BlackListedCommand, BzrError):
+            return os.system(line)
+
+        try:
+            if too_complicated(line):
+                return os.system("bzr "+line)
+            else:
+                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)
+        except BzrError, e:
+            print e
+        except KeyboardInterrupt, e:
+            print "Interrupted"
+        except Exception, e:
+#            print "Unhandled error:\n%s" % errors.exception_str(e)
+            print "Unhandled error:\n%s" % (e)
+
+
+    def completenames(self, text, line, begidx, endidx):
+        return CompletionContext(text).get_completions()
+
+    def completedefault(self, text, line, begidx, endidx):
+        """Perform completion for native commands.
+
+        :param text: The text to complete
+        :type text: str
+        :param line: The entire line to complete
+        :type line: str
+        :param begidx: The start of the text in the line
+        :type begidx: int
+        :param endidx: The end of the text in the line
+        :type endidx: int
+        """
+        (cmd, args, foo) = self.parseline(line)
+        if cmd == "bzr":
+            cmd = None
+        return CompletionContext(text, command=cmd).get_completions()
+
+
+def run_shell():
+    try:
+        prompt = PromptCmd()
+        try:
+            prompt.cmdloop()
+        finally:
+            prompt.write_history()
+    except StopIteration:
+        pass
+
+
+def iter_opt_completions(command_obj):
+    for option_name, option in command_obj.options().items():
+        yield "--" + option_name
+        short_name = option.short_name()
+        if short_name:
+            yield "-" + short_name
+
+
+def iter_file_completions(arg, only_dirs = False):
+    """Generate an iterator that iterates through filename completions.
+
+    :param arg: The filename fragment to match
+    :type arg: str
+    :param only_dirs: If true, match only directories
+    :type only_dirs: bool
+    """
+    cwd = os.getcwd()
+    if cwd != "/":
+        extras = [".", ".."]
+    else:
+        extras = []
+    (dir, file) = os.path.split(arg)
+    if dir != "":
+        listingdir = os.path.expanduser(dir)
+    else:
+        listingdir = cwd
+    for file in chain(os.listdir(listingdir), extras):
+        if dir != "":
+            userfile = dir+'/'+file
+        else:
+            userfile = file
+        if userfile.startswith(arg):
+            if os.path.isdir(listingdir+'/'+file):
+                userfile+='/'
+                yield userfile
+            elif not only_dirs:
+                yield userfile + ' '
+
+
+def iter_dir_completions(arg):
+    """Generate an iterator that iterates through directory name completions.
+
+    :param arg: The directory name fragment to match
+    :type arg: str
+    """
+    return iter_file_completions(arg, True)
+
+
+def iter_command_names(hidden=False):
+    for real_cmd_name, cmd_class in get_all_cmds():
+        if not hidden and cmd_class.hidden:
+            continue
+        for name in [real_cmd_name] + cmd_class.aliases:
+            # Don't complete on aliases that are prefixes of the canonical name
+            if name == real_cmd_name or not real_cmd_name.startswith(name):
+                yield name
+
+
+def iter_executables(path):
+    dirname, partial = os.path.split(path)
+    for filename in os.listdir(dirname):
+        if not filename.startswith(partial):
+            continue
+        fullpath = os.path.join(dirname, filename)
+        mode=os.lstat(fullpath)[stat.ST_MODE]
+        if stat.S_ISREG(mode) and 0111 & mode:
+            yield fullpath + ' '
+
+
+def filter_completions(iter, arg):
+    return (c for c in iter if c.startswith(arg))
+
+
+def iter_munged_completions(iter, arg, text):
+    for completion in iter:
+        completion = str(completion)
+        if completion.startswith(arg):
+            yield completion[len(arg)-len(text):]+" "
+
+
+def too_complicated(line):
+    for char in '|<>*?':
+        if char in line:
+            return True
+    return False
+
+    
+### IPython mods start
+
+def init_ipython(ip):
+    def bzr_completer(self,ev):
+        #print "bzr complete"
+        tup =  ev.line.split(None,2)
+        if len(tup) > 2:
+            cmd = tup[1]
+        else:
+            cmd = None
+                  
+        return CompletionContext(ev.symbol, command = cmd).get_completions()
+    bzrlib.plugin.load_plugins()
+    ip.set_hook('complete_command', bzr_completer, str_key = 'bzr')    

IPython/Extensions/ipy_greedycompleter.py

@@ -0,0 +1,75 b''
+""" Greedy completer extension for IPython
+
+Normal tab completer refuses to evaluate nonsafe stuff. This will evaluate
+everything, so you need to consider the consequences of pressing tab 
+yourself!
+
+Note that this extension simplifies readline interaction by setting
+only whitespace as completer delimiter. If this works well, we will
+do the same in default completer.
+
+"""
+from IPython import generics,ipapi
+from IPython.genutils import dir2
+
+def attr_matches(self, text):
+    """Compute matches when text contains a dot.
+
+    MONKEYPATCHED VERSION (ipy_greedycompleter.py)
+    
+    Assuming the text is of the form NAME.NAME....[NAME], and is
+    evaluatable in self.namespace or self.global_namespace, it will be
+    evaluated and its attributes (as revealed by dir()) are used as
+    possible completions.  (For class instances, class members are are
+    also considered.)
+
+    WARNING: this can still invoke arbitrary C code, if an object
+    with a __getattr__ hook is evaluated.
+
+    """
+    import re
+
+    force_complete = 1
+    # Another option, seems to work great. Catches things like ''.<tab>
+    m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
+
+    if m:
+        expr, attr = m.group(1, 3)
+    else:
+        # force match - eval anything that ends with colon
+        if not force_complete:
+            return []
+                
+        m2 = re.match(r"(.+)\.(\w*)$", self.lbuf)
+        if not m2:
+            return []
+        expr, attr = m2.group(1,2)
+        
+            
+    try:        
+        obj = eval(expr, self.namespace)
+    except:
+        try:
+            obj = eval(expr, self.global_namespace)
+        except:
+            return []
+
+    words = dir2(obj)
+    
+    try:
+        words = generics.complete_object(obj, words)
+    except ipapi.TryNext:
+        pass
+    # Build match list to return
+    n = len(attr)
+    res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
+    return res
+
+def main():
+    import readline
+    readline.set_completer_delims(" \n\t")
+    # monkeypatch - the code will be folded to normal completer later on
+    import IPython.completer
+    IPython.completer.Completer.attr_matches = attr_matches
+
+main()
  No newline at end of file

IPython/Extensions/ipy_jot.py

@@ -0,0 +1,311 b''
+# -*- coding: utf-8 -*-
+"""
+%jot magic for lightweight persistence.
+
+Stores variables in Struct with some notes in PicleShare database
+
+
+"""
+
+from datetime import datetime 
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import pickleshare
+
+import inspect,pickle,os,sys,textwrap
+from IPython.FakeModule import FakeModule
+from IPython.ipstruct import Struct 
+
+
+def refresh_variables(ip, key=None):
+    db = ip.db
+    if key is None:
+        keys = db.keys('jot/*')
+    else:
+        keys = db.keys('jot/'+key)
+    for key in keys:
+        # strip autorestore
+        justkey = os.path.basename(key)
+        print "Restoring from", justkey, "..."
+        try:
+            obj = db[key]
+        except KeyError:
+            print "Unable to restore variable '%s', ignoring (use %%jot -d to forget!)" % justkey
+            print "The error was:",sys.exc_info()[0]
+        else:
+            #print "restored",justkey,"=",obj #dbg
+            try:
+                origname = obj.name
+            except:
+                ip.user_ns[justkey] = obj
+                print "Restored", justkey
+            else:
+                ip.user_ns[origname] = obj['val']
+                print "Restored", origname 
+
+def read_variables(ip, key=None):
+    db = ip.db
+    if key is None:
+        return None
+    else:
+        keys = db.keys('jot/'+key)
+    for key in keys:
+        # strip autorestore
+        justkey = os.path.basename(key)
+        print "restoring from ", justkey 
+        try:
+            obj = db[key]
+        except KeyError:
+            print "Unable to read variable '%s', ignoring (use %%jot -d to forget!)" % justkey
+            print "The error was:",sys.exc_info()[0]
+        else:
+            return obj
+
+
+def detail_variables(ip, key=None):
+    db, get = ip.db, ip.db.get
+ 
+    if key is None:
+        keys = db.keys('jot/*')
+    else:
+        keys = db.keys('jot/'+key)
+    if keys:
+        size = max(map(len,keys))
+    else:
+        size = 0
+
+    fmthead = '%-'+str(size)+'s [%s]'
+    fmtbody = 'Comment:\n %s'
+    fmtdata = 'Data:\n %s, %s'
+    for key in keys:
+        v = get(key,'<unavailable>')
+        justkey = os.path.basename(key)
+        try: 
+            print fmthead % (justkey, datetime.ctime(v.get('time','<unavailable>')))
+            print fmtbody % (v.get('comment','<unavailable>'))
+            d = v.get('val','unavailable')
+            print fmtdata % (repr(type(d)), '')
+            print repr(d)[0:200]
+            print
+            print
+        except AttributeError:
+            print fmt % (justkey, '<unavailable>', '<unavailable>', repr(v)[:50])
+
+
+def intm(n):
+    try:
+        return int(n)
+    except:
+        return 0
+
+def jot_obj(self, obj, name, comment=''):
+    """
+    write obj data to the note database, with whatever that should be noted.
+    """
+    had = self.db.keys('jot/'+name+'*')
+    # if it the same name but a later version, we stupidly add a number to the 
+    # so the name doesn't collide. Any better idea?
+    suffix = ''
+    if len(had)>0:
+        pre = os.path.commonprefix(had)
+        suf = [n.split(pre)[1] for n in had]
+        versions = map(intm, suf)
+        suffix = str(max(versions)+1)
+
+    uname = 'jot/'+name+suffix
+
+    # which one works better? 
+    #all = ip.IP.shadowhist.all()
+    all = ip.IP.shell.input_hist
+
+    # We may actually want to make snapshot of files that are run-ned.
+
+    # get the comment 
+    try:
+        comment = ip.IP.magic_edit('-x').strip()
+    except:
+        print "No comment is recorded."
+        comment = ''
+
+    self.db[uname] = Struct({'val':obj, 
+                'time'  :   datetime.now(), 
+                'hist'  :   all,
+                'name'  :   name,
+                'comment' : comment,})
+
+    print "Jotted down notes for '%s' (%s)" % (uname, obj.__class__.__name__)
+
+    
+
+def magic_jot(self, parameter_s=''):
+    """Lightweight persistence for python variables.
+
+    Example:
+    
+    ville@badger[~]|1> A = ['hello',10,'world']\\
+    ville@badger[~]|2> %jot A\\
+    ville@badger[~]|3> Exit
+    
+    (IPython session is closed and started again...)
+    
+    ville@badger:~$ ipython -p pysh\\
+    ville@badger[~]|1> print A
+    
+    ['hello', 10, 'world']
+    
+    Usage:
+    
+    %jot          - Show list of all variables and their current values\\
+    %jot -l       - Show list of all variables and their current values in detail\\
+    %jot -l <var> - Show one variable and its current values in detail\\
+    %jot <var>    - Store the *current* value of the variable to disk\\
+    %jot -d <var> - Remove the variable and its value from storage\\
+    %jot -z       - Remove all variables from storage (disabled)\\
+    %jot -r <var> - Refresh/Load variable from jot (delete current vals)\\
+    %jot foo >a.txt  - Store value of foo to new file a.txt\\
+    %jot foo >>a.txt - Append value of foo to file a.txt\\   
+    
+    It should be noted that if you change the value of a variable, you
+    need to %note it again if you want to persist the new value.
+    
+    Note also that the variables will need to be pickleable; most basic
+    python types can be safely %stored.
+    
+    """
+    
+    opts,argsl = self.parse_options(parameter_s,'drzl',mode='string')
+    args = argsl.split(None,1)
+    ip = self.getapi()
+    db = ip.db
+    # delete
+    if opts.has_key('d'):
+        try:
+            todel = args[0]
+        except IndexError:
+            error('You must provide the variable to forget')
+        else:
+            try:
+                del db['jot/' + todel]
+            except:
+                error("Can't delete variable '%s'" % todel)
+    # reset the whole database
+    elif opts.has_key('z'):
+        print "reseting the whole database has been disabled."
+        #for k in db.keys('autorestore/*'):
+        #    del db[k]
+
+    elif opts.has_key('r'):
+        try:
+            toret = args[0]
+        except:
+            print "restoring all the variables jotted down..."
+            refresh_variables(ip)
+        else:
+            refresh_variables(ip, toret)
+
+    elif opts.has_key('l'):
+        try:
+            tolist = args[0]
+        except:
+            print "List details for all the items."
+            detail_variables(ip)
+        else:
+            print "Details for", tolist, ":"
+            detail_variables(ip, tolist)
+    
+    # run without arguments -> list noted variables & notes 
+    elif not args:
+        vars = self.db.keys('jot/*')
+        vars.sort()            
+        if vars:
+            size = max(map(len,vars)) - 4 
+        else:
+            size = 0
+            
+        print 'Variables and their in-db values:'
+        fmt = '%-'+str(size)+'s [%s] -> %s'
+        get = db.get
+        for var in vars:
+            justkey = os.path.basename(var)
+            v = get(var,'<unavailable>')
+            try: 
+                print fmt % (justkey,\
+                    datetime.ctime(v.get('time','<unavailable>')),\
+                    v.get('comment','<unavailable>')[:70].replace('\n',' '),)
+            except AttributeError:
+                print fmt % (justkey, '<unavailable>', '<unavailable>', repr(v)[:50])
+
+    
+    # default action - store the variable
+    else:
+        # %store foo >file.txt or >>file.txt
+        if len(args) > 1 and args[1].startswith('>'):
+            fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
+            if args[1].startswith('>>'):
+                fil = open(fnam,'a')
+            else:
+                fil = open(fnam,'w')
+            obj = ip.ev(args[0])
+            print "Writing '%s' (%s) to file '%s'." % (args[0],
+              obj.__class__.__name__, fnam)
+
+            
+            if not isinstance (obj,basestring):
+                from pprint import pprint
+                pprint(obj,fil)
+            else:
+                fil.write(obj)
+                if not obj.endswith('\n'):
+                    fil.write('\n')
+            
+            fil.close()
+            return
+        
+        # %note foo
+        try:
+            obj = ip.user_ns[args[0]]
+        except KeyError:
+            # this should not be alias, for aliases, use %store
+            print
+            print "Error: %s doesn't exist." % args[0]
+            print 
+            print "Use %note -r <var> to retrieve variables. This should not be used " +\
+                  "to store alias, for saving aliases, use %store" 
+            return
+        else:
+            if isinstance(inspect.getmodule(obj), FakeModule):
+                print textwrap.dedent("""\
+                Warning:%s is %s 
+                Proper storage of interactively declared classes (or instances
+                of those classes) is not possible! Only instances
+                of classes in real modules on file system can be %%store'd.
+                """ % (args[0], obj) ) 
+                return
+            #pickled = pickle.dumps(obj)
+            #self.db[ 'jot/' + args[0] ] = obj
+            jot_obj(self, obj, args[0])
+
+
+def magic_read(self, parameter_s=''):
+    """    
+    %read <var> - Load variable from data that is jotted down.\\
+    
+    """
+    
+    opts,argsl = self.parse_options(parameter_s,'drzl',mode='string')
+    args = argsl.split(None,1)
+    ip = self.getapi()
+    db = ip.db
+    #if opts.has_key('r'):
+    try:
+        toret = args[0]
+    except:
+        print "which record do you want to read out?"
+        return
+    else:
+        return read_variables(ip, toret)
+
+
+ip.expose_magic('jot',magic_jot)
+ip.expose_magic('read',magic_read)

IPython/Extensions/ipy_lookfor.py

@@ -0,0 +1,234 b''
+"""
+IPython extension: %lookfor command for searching docstrings
+
+"""
+# Pauli Virtanen <[e-mail]>, 2008.
+
+import re, inspect, pkgutil, pydoc
+
+#------------------------------------------------------------------------------
+# Lookfor functionality
+#------------------------------------------------------------------------------
+
+# Cache for lookfor: {id(module): {name: (docstring, kind, index), ...}...}
+# where kind: "func", "class", "module", "object"
+# and index: index in breadth-first namespace traversal
+_lookfor_caches = {}
+
+# regexp whose match indicates that the string may contain a function signature
+_function_signature_re = re.compile(r"[a-z_]+\(.*[,=].*\)", re.I)
+
+def lookfor(what, modules=None, import_modules=True, regenerate=False):
+    """
+    Search for objects whose documentation contains all given words.
+    Shows a summary of matching objects, sorted roughly by relevance.
+
+    Parameters
+    ----------
+    what : str
+        String containing words to look for.
+
+    module : str, module
+        Module whose docstrings to go through.
+    import_modules : bool
+        Whether to import sub-modules in packages.
+        Will import only modules in __all__
+    regenerate: bool
+        Re-generate the docstring cache
+
+    """
+    # Cache
+    cache = {}
+    for module in modules:
+        try:
+            c = _lookfor_generate_cache(module, import_modules, regenerate)
+            cache.update(c)
+        except ImportError:
+            pass
+    
+    # Search
+    # XXX: maybe using a real stemming search engine would be better?
+    found = []
+    whats = str(what).lower().split()
+    if not whats: return
+
+    for name, (docstring, kind, index) in cache.iteritems():
+        if kind in ('module', 'object'): 
+            # don't show modules or objects
+            continue
+        ok = True
+        doc = docstring.lower()
+        for w in whats:
+            if w not in doc:
+                ok = False
+                break
+        if ok:
+            found.append(name)
+
+    # Relevance sort
+    # XXX: this is full Harrison-Stetson heuristics now,
+    # XXX: it probably could be improved
+
+    kind_relevance = {'func': 1000, 'class': 1000, 
+                      'module': -1000, 'object': -1000}
+
+    def relevance(name, docstr, kind, index):
+        r = 0
+        # do the keywords occur within the start of the docstring?
+        first_doc = "\n".join(docstr.lower().strip().split("\n")[:3])
+        r += sum([200 for w in whats if w in first_doc])
+        # do the keywords occur in the function name?
+        r += sum([30 for w in whats if w in name])
+        # is the full name long?
+        r += -len(name) * 5
+        # is the object of bad type?
+        r += kind_relevance.get(kind, -1000)
+        # is the object deep in namespace hierarchy?
+        r += -name.count('.') * 10
+        r += max(-index / 100, -100)
+        return r
+
+    def relevance_sort(a, b):
+        dr = relevance(b, *cache[b]) - relevance(a, *cache[a])
+        if dr != 0: return dr
+        else: return cmp(a, b)
+    found.sort(relevance_sort)
+
+    # Pretty-print
+    s = "Search results for '%s'" % (' '.join(whats))
+    help_text = [s, "-"*len(s)]
+    for name in found:
+        doc, kind, ix = cache[name]
+
+        doclines = [line.strip() for line in doc.strip().split("\n")
+                    if line.strip()]
+
+        # find a suitable short description
+        try:
+            first_doc = doclines[0].strip()
+            if _function_signature_re.search(first_doc):
+                first_doc = doclines[1].strip()
+        except IndexError:
+            first_doc = ""
+        help_text.append("%s\n    %s" % (name, first_doc))
+
+    # Output
+    if len(help_text) > 10:
+        pager = pydoc.getpager()
+        pager("\n".join(help_text))
+    else:
+        print "\n".join(help_text)
+
+def _lookfor_generate_cache(module, import_modules, regenerate):
+    """
+    Generate docstring cache for given module.
+
+    Parameters
+    ----------
+    module : str, None, module
+        Module for which to generate docstring cache
+    import_modules : bool
+        Whether to import sub-modules in packages.
+        Will import only modules in __all__
+    regenerate: bool
+        Re-generate the docstring cache
+
+    Returns
+    -------
+    cache : dict {obj_full_name: (docstring, kind, index), ...}
+        Docstring cache for the module, either cached one (regenerate=False)
+        or newly generated.
+        
+    """
+    global _lookfor_caches
+
+    if module is None:
+        module = "numpy"
+
+    if isinstance(module, str):
+        module = __import__(module)
+
+    if id(module) in _lookfor_caches and not regenerate:
+        return _lookfor_caches[id(module)]
+
+    # walk items and collect docstrings
+    cache = {}
+    _lookfor_caches[id(module)] = cache
+    seen = {}
+    index = 0
+    stack = [(module.__name__, module)]
+    while stack:
+        name, item = stack.pop(0)
+        if id(item) in seen: continue
+        seen[id(item)] = True
+
+        index += 1
+        kind = "object"
+       
+        if inspect.ismodule(item):
+            kind = "module"
+            try:
+                _all = item.__all__
+            except AttributeError:
+                _all = None
+            # import sub-packages
+            if import_modules and hasattr(item, '__path__'):
+                for m in pkgutil.iter_modules(item.__path__):
+                    if _all is not None and m[1] not in _all:
+                        continue
+                    try:
+                        __import__("%s.%s" % (name, m[1]))
+                    except ImportError:
+                        continue
+            for n, v in inspect.getmembers(item):
+                if _all is not None and n not in _all:
+                    continue
+                stack.append(("%s.%s" % (name, n), v))
+        elif inspect.isclass(item):
+            kind = "class"
+            for n, v in inspect.getmembers(item):
+                stack.append(("%s.%s" % (name, n), v))
+        elif callable(item):
+            kind = "func"
+        
+        doc = inspect.getdoc(item)
+        if doc is not None:
+            cache[name] = (doc, kind, index)
+
+    return cache
+
+#------------------------------------------------------------------------------
+# IPython connectivity
+#------------------------------------------------------------------------------
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+_lookfor_modules = ['numpy', 'scipy']
+
+def lookfor_f(self, arg=''):
+    r"""
+    Search for objects whose documentation contains all given words.
+    Shows a summary of matching objects, sorted roughly by relevance.
+
+    Usage
+    -----
+    %lookfor +numpy  some words
+    Search module 'numpy'
+
+    %lookfor_modules numpy scipy
+    Set default modules whose docstrings to search
+
+    """
+    lookfor(arg, modules=_lookfor_modules)
+
+def lookfor_modules_f(self, arg=''):
+    global _lookfor_modules
+    if not arg:
+        print "Modules included in %lookfor search:", _lookfor_modules
+    else:
+        _lookfor_modules = arg.split()
+
+ip.expose_magic('lookfor', lookfor_f)
+ip.expose_magic('lookfor_modules', lookfor_modules_f)
+

IPython/Extensions/ipy_vimserver.py

@@ -0,0 +1,239 b''
+""" Integration with gvim, by Erich Heine
+
+Provides a %vim magic command, and reuses the same vim session. Uses 
+unix domain sockets for communication between vim and IPython. ipy.vim is 
+available in doc/examples of the IPython distribution.
+
+Slightly touched up email announcement (and description how to use it) by 
+Erich Heine is here:
+
+Ive recently been playing with ipython, and like it quite a bit. I did
+however discover a bit of frustration, namely with editor interaction.
+I am a gvim user, and using the command edit on a new file causes
+ipython to try and run that file as soon as the text editor opens
+up. The -x command of course fixes this, but its still a bit annoying,
+switching windows to do a run file, then back to the text
+editor. Being a heavy tab user in gvim, another annoyance is not being
+able to specify weather a new tab is how I choose to open the file.
+
+Not being one to shirk my open source duties (and seeing this as a
+good excuse to poke around ipython internals), Ive created a script
+for having gvim and ipython work very nicely together. Ive attached
+both to this email (hoping of course that the mailing list allows such
+things).
+
+There are 2 files: 
+
+ipy_vimserver.py -- this file contains the ipython stuff
+ipy.vim -- this file contains the gvim stuff
+
+In combination they allow for a few functionalities:
+
+#1. the vim magic command. This is a fancy wrapper around the edit
+magic, that allows for a new option, -t, which opens the text in a new
+gvim tab.  Otherwise it works the same as edit -x. (it internally
+calls edit -x). This magic command also juggles vim server management,
+so when it is called when there is not a gvim running, it creates a
+new gvim instance, named after the ipython session name.  Once such a
+gvim instance is running, it will be used for subsequent uses of the
+vim command.
+
+#2. ipython - gvim interaction. Once a file has been opened with the
+vim magic (and a session set up, see below), pressing the F5 key in
+vim will cause the calling ipython instance to execute run
+filename.py. (if you typo like I do, this is very useful)
+
+#3. ipython server - this is a thread wich listens on a unix domain
+socket, and runs commands sent to that socket.
+
+Note, this only works on POSIX systems, that allow for AF_UNIX type
+sockets. It has only been tested on linux (a fairly recent debian
+testing distro).
+
+To install it put, the ipserver.py in your favorite locaion for
+sourcing ipython scripts. I put the ipy.vim in
+~/.vim/after/ftplugin/python/.
+
+To use (this can be scripted im sure, but i usually have 2 or 3
+ipythons and corresponding gvims open):
+
+import ipy_vimserver
+ipy_vimserver.setup('sessionname')
+
+(Editors note - you can probably add these to your ipy_user_conf.py)
+
+Then use ipython as you normally would, until you need to edit
+something. Instead of edit, use the vim magic.  Thats it!
+
+"""
+
+import IPython.ipapi
+#import ipythonhooks
+import socket, select
+import os, threading, subprocess
+import re
+
+ERRCONDS = select.POLLHUP|select.POLLERR
+SERVER = None
+ip = IPython.ipapi.get()
+
+# this listens to a unix domain socket in a separate thread, so that comms
+# between a vim instance and ipython can happen in a fun and productive way
+class IpyServer(threading.Thread):
+    def __init__(self, sname):
+        super(IpyServer, self).__init__()
+        self.keep_running = True
+        self.__sname = sname
+        self.socket = socket.socket(socket.AF_UNIX)
+        self.poller = select.poll()
+        self.current_conns = dict()
+        self.setDaemon(True)
+
+    def listen(self):
+        self.socket.bind(self.__sname)
+        self.socket.listen(1)
+
+    def __handle_error(self, socket):
+        if socket == self.socket.fileno():
+            self.keep_running = False
+            for a in self.current_conns.values():
+                a.close()
+            return False
+        else:
+            y = self.current_conns[socket]
+            del self.current_conns[socket]
+        y.close()
+        self.poller.unregister(socket)
+
+    def serve_me(self):
+        self.listen()
+        self.poller.register(self.socket,select.POLLIN|ERRCONDS)
+
+        while self.keep_running:
+            try:
+                avail = self.poller.poll(1)
+            except:
+                continue
+
+            if not avail: continue
+
+            for sock, conds in avail:
+                if conds & (ERRCONDS):
+                    if self.__handle_error(sock): continue
+                    else: break
+
+                if sock == self.socket.fileno():
+                    y = self.socket.accept()[0]
+                    self.poller.register(y, select.POLLIN|ERRCONDS)
+                    self.current_conns[y.fileno()] = y
+                else: y = self.current_conns.get(sock)
+
+                self.handle_request(y)
+
+        os.remove(self.__sname)
+
+    run = serve_me
+
+    def stop(self):
+        self.keep_running = False
+
+    def handle_request(self,sock):
+        sock.settimeout(1)
+        while self.keep_running:
+            try:
+                x = sock.recv(4096)
+            except socket.timeout:
+                pass
+            else:
+                break
+        self.do_it(x)
+
+    def do_it(self, data):
+        data = data.split('\n')
+        cmds = list()
+        for line in data:
+            cmds.append(line)
+        ip.runlines(cmds)
+
+
+# try to help ensure that the unix domain socket is cleaned up proper
+def shutdown_server(self):
+    if SERVER:
+        SERVER.stop()
+        SERVER.join(3)
+    raise IPython.ipapi.TryNext
+
+ip.set_hook('shutdown_hook', shutdown_server, 10)
+
+# this fun function exists to make setup easier for all, and makes the
+# vimhook function ready for instance specific communication
+def setup(sessionname='',socketdir=os.path.expanduser('~/.ipython/')):
+    global SERVER
+
+    if sessionname:
+        session = sessionname
+    elif os.environ.get('IPY_SESSION'):
+        session = os.environ.get('IPY_SESSION')
+    else:
+        session = 'IPYS'
+    vimhook.vimserver=session
+    vimhook.ipyserver = os.path.join(socketdir, session)
+    if not SERVER:
+        SERVER = IpyServer(vimhook.ipyserver)
+        SERVER.start()
+
+
+
+# calls gvim, with all ops happening on the correct gvim instance for this
+# ipython instance. it then calls edit -x (since gvim will return right away)
+# things of note: it sets up a special environment, so that the ipy.vim script
+# can connect back to the ipython instance and do fun things, like run the file
+def vimhook(self, fname, line):
+    env = os.environ.copy()
+    vserver = vimhook.vimserver.upper()
+    check = subprocess.Popen('gvim --serverlist', stdout = subprocess.PIPE,
+        shell=True)
+    check.wait()
+    cval = [l for l in check.stdout.readlines() if vserver in l]
+
+    if cval:
+        vimargs = '--remote%s' % (vimhook.extras,)
+    else:
+        vimargs = ''
+    vimhook.extras = ''
+
+    env['IPY_SESSION'] = vimhook.vimserver
+    env['IPY_SERVER'] = vimhook.ipyserver
+
+    if line is None: line = ''
+    else: line = '+' + line
+    vim_cmd = 'gvim --servername %s %s %s %s' % (vimhook.vimserver, vimargs,
+        line, fname)
+    subprocess.call(vim_cmd, env=env, shell=True)
+
+
+#default values to keep it sane...
+vimhook.vimserver = ''
+vimhook.ipyserver = ''
+
+ip.set_hook('editor',vimhook)
+
+# this is set up so more vim specific commands can be added, instead of just
+# the current -t. all thats required is a compiled regex, a call to do_arg(pat)
+# and the logic to deal with the new feature
+newtab = re.compile(r'-t(?:\s|$)')
+def vim(self, argstr):
+    def do_arg(pat, rarg):
+        x = len(pat.findall(argstr))
+        if x:
+            a = pat.sub('',argstr)
+            return rarg, a
+        else: return '', argstr
+
+    t, argstr = do_arg(newtab, '-tab')
+    vimhook.extras = t
+    argstr = 'edit -x ' + argstr
+    ip.magic(argstr)
+
+ip.expose_magic('vim', vim)
+

IPython/Extensions/ipy_winpdb.py

@@ -0,0 +1,73 b''
+""" Debug a script (like %run -d) in IPython process, Using WinPdb
+
+Usage:
+
+%wdb test.py
+    run test.py, with a winpdb breakpoint at start of the file 
+    
+%wdb pass
+    Change the password (e.g. if you have forgotten the old one)
+"""
+
+import os
+
+import IPython.ipapi
+import rpdb2
+
+ip = IPython.ipapi.get()
+
+rpdb_started = False
+
+def wdb_f(self, arg):
+    """ Debug a script (like %run -d) in IPython process, Using WinPdb
+    
+    Usage:
+    
+    %wdb test.py
+        run test.py, with a winpdb breakpoint at start of the file 
+        
+    %wdb pass
+        Change the password (e.g. if you have forgotten the old one)
+        
+    Note that after the script has been run, you need to do "Go" (f5) 
+    in WinPdb to resume normal IPython operation.
+    """
+
+    global rpdb_started
+    if not arg.strip():
+        print __doc__
+        return
+        
+    if arg.strip() == 'pass':
+        passwd = raw_input('Enter new winpdb session password: ')
+        ip.db['winpdb_pass'] = passwd
+        print "Winpdb password changed"
+        if rpdb_started:
+            print "You need to restart IPython to use the new password"
+        return 
+    
+    path = os.path.abspath(arg)
+    if not os.path.isfile(path):
+        raise IPython.ipapi.UsageError("%%wdb: file %s does not exist" % path)
+    if not rpdb_started:
+        passwd = ip.db.get('winpdb_pass', None)
+        if passwd is None:
+            import textwrap
+            print textwrap.dedent("""\
+            Winpdb sessions need a password that you use for attaching the external
+            winpdb session. IPython will remember this. You can change the password later 
+            by '%wpdb pass'
+            """)
+            passwd = raw_input('Enter new winpdb session password: ')
+            ip.db['winpdb_pass'] = passwd
+            
+        print "Starting rpdb2 in IPython process"
+        rpdb2.start_embedded_debugger(passwd, timeout = 0)
+        rpdb_started = True
+        
+    rpdb2.set_temp_breakpoint(path)
+    print 'It is time to attach with WinPdb (launch WinPdb if needed, File -> Attach)'
+    ip.magic('%run ' + arg)
+    
+
+ip.expose_magic('wdb', wdb_f)

IPython/gui/wx/ipshell_nonblocking.py

@@ -0,0 +1,460 b''
+#!/usr/bin/python
+# -*- coding: iso-8859-15 -*-
+'''
+Provides IPython remote instance.
+
+@author: Laurent Dufrechou
+laurent.dufrechou _at_ gmail.com
+@license: BSD
+
+All rights reserved. This program and the accompanying materials are made
+available under the terms of the BSD which accompanies this distribution, and
+is available at U{http://www.opensource.org/licenses/bsd-license.php}
+'''
+
+__version__ = 0.9
+__author__  = "Laurent Dufrechou"
+__email__   = "laurent.dufrechou _at_ gmail.com"
+__license__ = "BSD"
+
+import re
+import sys
+import os
+import locale
+import time
+import pydoc,__builtin__,site
+from thread_ex import ThreadEx
+from StringIO import StringIO
+
+try:
+        import IPython
+except Exception,e:
+        raise "Error importing IPython (%s)" % str(e)
+
+##############################################################################
+class _Helper(object):
+    """Redefine the built-in 'help'.
+    This is a wrapper around pydoc.help (with a twist).
+    """
+
+    def __init__(self,pager):
+        self._pager = pager
+
+    def __repr__(self):
+        return "Type help() for interactive help, " \
+               "or help(object) for help about object."
+    
+    def __call__(self, *args, **kwds):
+        class DummyWriter(object):
+            def __init__(self,pager):
+                self._pager = pager
+                
+            def write(self,data):
+                self._pager(data)
+
+        import pydoc
+        pydoc.help.output = DummyWriter(self._pager)
+        pydoc.help.interact = lambda :1
+        
+        return pydoc.help(*args, **kwds)
+
+  
+##############################################################################
+class _CodeExecutor(ThreadEx):
+    
+    def __init__(self, instance, after):
+        ThreadEx.__init__(self)
+        self.instance = instance
+        self._afterExecute=after
+
+    def run(self):
+        try:
+            self.instance._doc_text = None
+            self.instance._help_text = None
+            self.instance._execute()
+            # used for uper class to generate event after execution
+            self._afterExecute() 
+            
+        except KeyboardInterrupt:
+            pass
+ 
+
+##############################################################################
+class NonBlockingIPShell(object):
+    '''
+    Create an IPython instance, running the commands in a separate,
+    non-blocking thread. 
+    This allows embedding in any GUI without blockage.
+
+    Note: The ThreadEx class supports asynchroneous function call
+          via raise_exc()
+    '''
+
+    def __init__(self,argv=[],user_ns={},user_global_ns=None,
+                 cin=None, cout=None, cerr=None,
+                 ask_exit_handler=None):
+        '''
+        @param argv: Command line options for IPython
+        @type argv: list
+        @param user_ns: User namespace.
+        @type user_ns: dictionary
+        @param user_global_ns: User global namespace.
+        @type user_global_ns: dictionary.
+        @param cin: Console standard input.
+        @type cin: IO stream
+        @param cout: Console standard output.
+        @type cout: IO stream
+        @param cerr: Console standard error.
+        @type cerr: IO stream
+        @param exit_handler: Replacement for builtin exit() function
+        @type exit_handler: function
+        @param time_loop: Define the sleep time between two thread's loop
+        @type int
+        '''
+        #ipython0 initialisation
+        self.initIpython0(argv, user_ns, user_global_ns,
+                          cin, cout, cerr,
+                          ask_exit_handler)
+        
+        #vars used by _execute
+        self._iter_more = 0
+        self._history_level = 0
+        self._complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
+        self._prompt = str(self._IP.outputcache.prompt1).strip()
+
+        #thread working vars
+        self._line_to_execute = ''
+
+        #vars that will be checked by GUI loop to handle thread states...
+        #will be replaced later by PostEvent GUI funtions...
+        self._doc_text = None
+        self._help_text = None
+        self._add_button = None
+
+    def initIpython0(self, argv=[], user_ns={}, user_global_ns=None,
+                     cin=None, cout=None, cerr=None,
+                     ask_exit_handler=None):
+        #first we redefine in/out/error functions of IPython 
+        if cin:
+            IPython.Shell.Term.cin = cin
+        if cout:
+            IPython.Shell.Term.cout = cout
+        if cerr:
+            IPython.Shell.Term.cerr = cerr
+        
+        # This is to get rid of the blockage that accurs during
+        # IPython.Shell.InteractiveShell.user_setup()
+        IPython.iplib.raw_input = lambda x: None
+
+        self._term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)
+
+        excepthook = sys.excepthook
+
+        self._IP = IPython.Shell.make_IPython(
+                                            argv,user_ns=user_ns,
+                                            user_global_ns=user_global_ns,
+                                            embedded=True,
+                                            shell_class=IPython.Shell.InteractiveShell)
+
+        #we replace IPython default encoding by wx locale encoding
+        loc = locale.getpreferredencoding()
+        if loc:
+                self._IP.stdin_encoding = loc
+        #we replace the ipython default pager by our pager
+        self._IP.set_hook('show_in_pager',self._pager)
+        
+        #we replace the ipython default shell command caller by our shell handler
+        self._IP.set_hook('shell_hook',self._shell)
+        
+        #we replace the ipython default input command caller by our method
+        IPython.iplib.raw_input_original = self._raw_input
+        #we replace the ipython default exit command by our method
+        self._IP.exit = ask_exit_handler
+        #we replace the help command
+        self._IP.user_ns['help'] = _Helper(self._pager_help)
+
+        #we disable cpase magic... until we found a way to use it properly.
+        #import IPython.ipapi
+        ip = IPython.ipapi.get()
+        def bypassMagic(self, arg):
+            print '%this magic is currently disabled.'
+        ip.expose_magic('cpaste', bypassMagic)
+        
+        sys.excepthook = excepthook
+
+    #----------------------- Thread management section ----------------------    
+    def doExecute(self,line):
+        """
+        Tell the thread to process the 'line' command
+        """
+
+        self._line_to_execute = line
+        #we launch the ipython line execution in a thread to make it interruptible
+        self.ce = _CodeExecutor(self,self._afterExecute)
+        self.ce.start()
+        
+    #----------------------- IPython management section ----------------------    
+    def getDocText(self):
+        """
+        Returns the output of the processing that need to be paged (if any)
+
+        @return: The std output string.
+        @rtype: string
+        """
+        return self._doc_text
+        
+    def getHelpText(self):
+        """
+        Returns the output of the processing that need to be paged via help pager(if any)
+
+        @return: The std output string.
+        @rtype: string
+        """
+        return self._help_text
+
+    def getBanner(self):
+        """
+        Returns the IPython banner for useful info on IPython instance
+
+        @return: The banner string.
+        @rtype: string
+        """
+        return self._IP.BANNER
+    
+    def getPromptCount(self):
+        """
+        Returns the prompt number.
+        Each time a user execute a line in the IPython shell the prompt count is increased
+
+        @return: The prompt number
+        @rtype: int
+        """
+        return self._IP.outputcache.prompt_count
+
+    def getPrompt(self):
+        """
+        Returns current prompt inside IPython instance
+        (Can be In [...]: ot ...:)
+
+        @return: The current prompt.
+        @rtype: string
+        """
+        return self._prompt
+
+    def getIndentation(self):
+        """
+        Returns the current indentation level
+        Usefull to put the caret at the good start position if we want to do autoindentation.
+
+        @return: The indentation level.
+        @rtype: int
+        """
+        return self._IP.indent_current_nsp
+        
+    def updateNamespace(self, ns_dict):
+        '''
+        Add the current dictionary to the shell namespace.
+
+        @param ns_dict: A dictionary of symbol-values.
+        @type ns_dict: dictionary
+        '''
+        self._IP.user_ns.update(ns_dict)
+
+    def complete(self, line):
+        '''
+        Returns an auto completed line and/or posibilities for completion.
+
+        @param line: Given line so far.
+        @type line: string
+
+        @return: Line completed as for as possible,
+        and possible further completions.
+        @rtype: tuple
+        '''
+        split_line = self._complete_sep.split(line)
+        possibilities = self._IP.complete(split_line[-1])
+        if possibilities:
+
+            def _commonPrefix(str1, str2):
+                '''
+                Reduction function. returns common prefix of two given strings.
+
+                @param str1: First string.
+                @type str1: string
+                @param str2: Second string
+                @type str2: string
+
+                @return: Common prefix to both strings.
+                @rtype: string
+                '''
+                for i in range(len(str1)):
+                    if not str2.startswith(str1[:i+1]):
+                        return str1[:i]
+                return str1
+            common_prefix = reduce(_commonPrefix, possibilities)
+            completed = line[:-len(split_line[-1])]+common_prefix
+        else:
+            completed = line
+        return completed, possibilities
+
+    def historyBack(self):
+        '''
+        Provides one history command back.
+
+        @return: The command string.
+        @rtype: string
+        '''
+        history = ''
+        #the below while loop is used to suppress empty history lines
+        while((history == '' or history == '\n') and self._history_level >0):
+                if self._history_level>=1:
+                        self._history_level -= 1
+                history = self._getHistory()            
+        return history
+
+    def historyForward(self):
+        '''
+        Provides one history command forward.
+
+        @return: The command string.
+        @rtype: string
+        '''
+        history = ''
+        #the below while loop is used to suppress empty history lines
+        while((history == '' or history == '\n') and self._history_level <= self._getHistoryMaxIndex()):
+                if self._history_level < self._getHistoryMaxIndex():
+                        self._history_level += 1
+                        history = self._getHistory()
+                else:
+                        if self._history_level == self._getHistoryMaxIndex():
+                                history = self._getHistory()
+                                self._history_level += 1
+                        else:
+                                history = ''
+        return history
+
+    def initHistoryIndex(self):
+        '''
+        set history to last command entered
+        '''
+        self._history_level = self._getHistoryMaxIndex()+1
+
+    #----------------------- IPython PRIVATE management section --------------
+    def _afterExecute(self):
+        '''
+        Can be redefined to generate post event after excution is done
+        '''
+        pass
+
+    #def _askExit(self):
+    #    '''
+    #    Can be redefined to generate post event to exit the Ipython shell
+    #    '''
+    #    pass
+
+    def _getHistoryMaxIndex(self):
+        '''
+        returns the max length of the history buffer
+
+        @return: history length
+        @rtype: int
+        '''
+        return len(self._IP.input_hist_raw)-1
+        
+    def _getHistory(self):
+        '''
+        Get's the command string of the current history level.
+
+        @return: Historic command stri
+        @rtype: string
+        '''
+        rv = self._IP.input_hist_raw[self._history_level].strip('\n')
+        return rv
+
+    def _pager_help(self,text):
+        '''
+        This function is used as a callback replacment to IPython help pager function
+
+        It puts the 'text' value inside the self._help_text string that can be retrived via getHelpText
+        function.
+        '''
+        if self._help_text == None:
+            self._help_text = text
+        else:
+            self._help_text += text
+    
+    def _pager(self,IP,text):
+        '''
+        This function is used as a callback replacment to IPython pager function
+
+        It puts the 'text' value inside the self._doc_text string that can be retrived via getDocText
+        function.
+        '''
+        self._doc_text = text
+    
+    def _raw_input(self, prompt=''):
+        '''
+        Custom raw_input() replacement. Get's current line from console buffer.
+
+        @param prompt: Prompt to print. Here for compatability as replacement.
+        @type prompt: string
+
+        @return: The current command line text.
+        @rtype: string
+        '''
+        return self._line_to_execute
+
+    def _execute(self):
+        '''
+        Executes the current line provided by the shell object.
+        '''
+        orig_stdout = sys.stdout
+        sys.stdout = IPython.Shell.Term.cout
+                
+        try:
+            line = self._IP.raw_input(None, self._iter_more)
+            if self._IP.autoindent:
+                self._IP.readline_startup_hook(None)
+
+        except KeyboardInterrupt:
+            self._IP.write('\nKeyboardInterrupt\n')
+            self._IP.resetbuffer()
+            # keep cache in sync with the prompt counter:
+            self._IP.outputcache.prompt_count -= 1
+
+            if self._IP.autoindent:
+                self._IP.indent_current_nsp = 0
+            self._iter_more = 0
+        except:
+            self._IP.showtraceback()
+        else:
+            self._iter_more = self._IP.push(line)
+            if (self._IP.SyntaxTB.last_syntax_error and
+                    self._IP.rc.autoedit_syntax):
+                self._IP.edit_syntax_error()
+        if self._iter_more:
+            self._prompt = str(self._IP.outputcache.prompt2).strip()
+            if self._IP.autoindent:
+                self._IP.readline_startup_hook(self._IP.pre_readline)
+        else:
+            self._prompt = str(self._IP.outputcache.prompt1).strip()
+            self._IP.indent_current_nsp = 0 #we set indentation to 0
+        sys.stdout = orig_stdout
+    
+    def _shell(self, ip, cmd):
+        '''
+        Replacement method to allow shell commands without them blocking.
+
+        @param ip: Ipython instance, same as self._IP
+        @type cmd: Ipython instance
+        @param cmd: Shell command to execute.
+        @type cmd: string
+        '''
+        stdin, stdout = os.popen4(cmd)
+        result = stdout.read().decode('cp437').encode(locale.getpreferredencoding())
+        #we use print command because the shell command is called inside IPython instance and thus is
+        #redirected to thread cout
+        #"\x01\x1b[1;36m\x02" <-- add colour to the text...
+        print "\x01\x1b[1;36m\x02"+result
+        stdout.close()
+        stdin.close()

IPython/gui/wx/options.conf

@@ -0,0 +1,6 b''
+completion=IPYTHON
+background_color=BLACK
+filter_empty=True
+filter_magic=True
+filter_doc=True
+filter_cmd=True

IPython/shellglobals.py

@@ -0,0 +1,96 b''
+from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
+
+import thread,inspect
+
+try:
+    import ctypes
+    HAS_CTYPES = True
+except ImportError:
+    HAS_CTYPES = False
+
+
+# Globals
+# global flag to pass around information about Ctrl-C without exceptions
+KBINT = False
+
+# global flag to turn on/off Tk support.
+USE_TK = False
+
+# ID for the main thread, used for cross-thread exceptions
+MAIN_THREAD_ID = thread.get_ident()
+
+# Tag when runcode() is active, for exception handling
+CODE_RUN = None
+
+
+#-----------------------------------------------------------------------------
+# 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.
+
+
+if HAS_CTYPES:
+    #  Add async exception support.  Trick taken from:
+    # http://sebulba.wikispaces.com/recipe+thread2
+    def _async_raise(tid, exctype):
+        """raises the exception, performs cleanup if needed"""
+        if not inspect.isclass(exctype):
+            raise TypeError("Only types can be raised (not instances)")
+        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid,
+                                                         ctypes.py_object(exctype))
+        if res == 0:
+            raise ValueError("invalid thread id")
+        elif res != 1:
+            # """if it returns a number greater than one, you're in trouble, 
+            # and you should call it again with exc=NULL to revert the effect"""
+            ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
+            raise SystemError("PyThreadState_SetAsyncExc failed")
+
+    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
+
+        if CODE_RUN:
+            _async_raise(MAIN_THREAD_ID,KeyboardInterrupt)
+        else:
+            KBINT = True
+            print '\nKeyboardInterrupt - Press <Enter> to continue.',
+            Term.cout.flush()
+
+else:
+    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
+
+def run_in_frontend(src):
+    """ Check if source snippet can be run in the REPL thread, as opposed to GUI mainloop
+    
+    (to prevent unnecessary hanging of mainloop).  
+    
+    """
+    
+    if src.startswith('_ip.system(') and not '\n' in src:
+        return True
+    return False
+    
+    
+    

IPython/twshell.py

@@ -0,0 +1,278 b''
+import sys
+
+from twisted.internet import reactor, threads
+
+from IPython.ipmaker import make_IPython
+from IPython.iplib import InteractiveShell 
+from IPython.ipstruct import Struct
+import Queue,thread,threading,signal
+from signal import signal, SIGINT
+from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
+import shellglobals
+
+def install_gtk2():
+    """ Install gtk2 reactor, needs to be called bef """
+    from twisted.internet import gtk2reactor
+    gtk2reactor.install()
+
+
+def hijack_reactor():
+    """Modifies Twisted's reactor with a dummy so user code does
+    not block IPython.  This function returns the original
+    'twisted.internet.reactor' that has been hijacked.
+
+    NOTE: Make sure you call this *AFTER* you've installed
+    the reactor of your choice.
+    """
+    from twisted import internet
+    orig_reactor = internet.reactor
+
+    class DummyReactor(object):
+        def run(self):
+            pass
+        def __getattr__(self, name):
+            return getattr(orig_reactor, name)
+        def __setattr__(self, name, value):
+            return setattr(orig_reactor, name, value)
+    
+    internet.reactor = DummyReactor()
+    return orig_reactor
+
+class TwistedInteractiveShell(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)
+
+
+        # A queue to hold the code to be executed. 
+        self.code_queue = Queue.Queue()
+
+        # Stuff to do at closing time
+        self._kill = None
+        on_kill = kw.get('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
+        # thread identity of the "worker thread" (that may execute code directly)
+        self.worker_ident = None
+        self.reactor_started = False
+        self.first_run = True
+        
+    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."""
+        
+        # If Ctrl-C was typed, we reset the flag and return right away
+        if shellglobals.KBINT:
+            shellglobals.KBINT = False
+            return False
+
+        if self._kill:
+            # can't queue new code if we are being killed
+            return True
+        
+        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
+
+        # shortcut - if we are in worker thread, or the worker thread is not running, 
+        # execute directly (to allow recursion and prevent deadlock if code is run early 
+        # in IPython construction)
+        
+        if (not self.reactor_started or (self.worker_ident is None and not self.first_run) 
+            or self.worker_ident == thread.get_ident() or shellglobals.run_in_frontend(source)):
+            InteractiveShell.runcode(self,code)
+            return
+
+        # Case 3
+        # Store code in queue, so the execution thread can handle it.
+ 
+        self.first_run = False
+        completed_ev, received_ev = threading.Event(), threading.Event() 
+        
+        self.code_queue.put((code,completed_ev, received_ev))
+
+        reactor.callLater(0.0,self.runcode)
+        received_ev.wait(5)
+        if not received_ev.isSet():
+            # the mainloop is dead, start executing code directly
+            print "Warning: Timeout for mainloop thread exceeded"
+            print "switching to nonthreaded mode (until mainloop wakes up again)"
+            self.worker_ident = None
+        else:            
+            completed_ev.wait()
+        
+        return False
+
+    def runcode(self):
+        """Execute a code object.
+
+        Multithreaded wrapper around IPython's runcode()."""
+        
+        
+        # we are in worker thread, stash out the id for runsource() 
+        self.worker_ident = thread.get_ident()
+
+        if self._kill:
+            print >>Term.cout, 'Closing threads...',
+            Term.cout.flush()
+            for tokill in self.on_kill:
+                tokill()
+            print >>Term.cout, 'Done.'
+            # allow kill() to return
+            self._kill.set()
+            return True
+
+        # Install SIGINT handler.  We do it every time to ensure that if user
+        # code modifies it, we restore our own handling.
+        try:
+            pass
+            signal(SIGINT,shellglobals.sigint_handler)
+        except SystemError:
+            # This happens under Windows, which seems to have all sorts
+            # of problems with signal handling.  Oh well...
+            pass
+
+        # Flush queue of pending code by calling the run methood of the parent
+        # class with all items which may be in the queue.
+        code_to_run = None
+        while 1:
+            try:
+                code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()                
+            except Queue.Empty:
+                break
+            received_ev.set()
+
+            
+            # Exceptions need to be raised differently depending on which
+            # thread is active.  This convoluted try/except is only there to
+            # protect against asynchronous exceptions, to ensure that a shellglobals.KBINT
+            # at the wrong time doesn't deadlock everything.  The global
+            # CODE_TO_RUN is set to true/false as close as possible to the
+            # runcode() call, so that the KBINT handler is correctly informed.
+            try:
+                try:
+                   shellglobals.CODE_RUN = True
+                   InteractiveShell.runcode(self,code_to_run)
+                except KeyboardInterrupt:
+                   print "Keyboard interrupted in mainloop"
+                   while not self.code_queue.empty():
+                      code = self.code_queue.get_nowait()
+                   break
+            finally:
+                shellglobals.CODE_RUN = False
+                # allow runsource() return from wait
+                completed_ev.set()                
+        
+        # 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._kill = threading.Event()
+        reactor.callLater(0.0,self.runcode)
+        self._kill.wait()
+
+
+
+class IPShellTwisted:
+    """Run a Twisted reactor while in an IPython session.
+
+    Python commands can be passed to the thread where they will be
+    executed.  This is implemented by periodically checking for
+    passed code using a Twisted reactor callback.
+    """
+
+    TIMEOUT = 0.01 # Millisecond interval between reactor runs.
+
+    def __init__(self, argv=None, user_ns=None, debug=1,
+                 shell_class=TwistedInteractiveShell):
+
+        from twisted.internet import reactor
+        self.reactor = hijack_reactor()
+
+        mainquit = self.reactor.stop
+
+        # Make sure IPython keeps going after reactor stop.
+        def reactorstop():
+            pass
+        self.reactor.stop = reactorstop
+        reactorrun_orig = self.reactor.run
+        self.quitting = False
+        def reactorrun():
+            while True and not self.quitting:
+                reactorrun_orig()
+        self.reactor.run = reactorrun
+        
+        self.IP = make_IPython(argv, user_ns=user_ns, debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[mainquit])
+
+        # threading.Thread.__init__(self)
+
+    def run(self):
+        self.IP.mainloop()
+        self.quitting = True
+        self.IP.kill()
+
+    def mainloop(self):
+        def mainLoopThreadDeath(r):
+            print "mainLoopThreadDeath: ", str(r)
+        def spawnMainloopThread():
+            d=threads.deferToThread(self.run)
+            d.addBoth(mainLoopThreadDeath)
+        reactor.callWhenRunning(spawnMainloopThread)
+        self.IP.reactor_started = True
+        self.reactor.run()
+        print "mainloop ending...."   
+        
+exists = True
+
+
+if __name__ == '__main__':
+    # Sample usage.
+
+    # Create the shell object. This steals twisted.internet.reactor
+    # for its own purposes, to make sure you've already installed a
+    # reactor of your choice.
+    shell = IPShellTwisted(
+        argv=[],
+        user_ns={'__name__': '__example__',
+                 'hello': 'world',
+                 },
+        )
+
+    # Run the mainloop.  This runs the actual reactor.run() method.
+    # The twisted.internet.reactor object at this point is a dummy
+    # object that passes through to the actual reactor, but prevents
+    # run() from being called on it again.
+    shell.mainloop()
+
+    # You must exit IPython to terminate your program.
+    print 'Goodbye!'
+

debian/install

@@ -0,0 +1,1 b''
+doc/ipython.el		usr/share/emacs/site-lisp

debian/irunner.1

@@ -0,0 +1,52 b''
+.TH IRUNNER 1 "April 24, 2007" "" ""
+.SH NAME
+\fBirunner \- interactive runner interface
+.SH SYNOPSIS
+.nf
+.fam C
+\fBirunner\fP [\fIoptions\fP] \fIfile_to_run\fP
+.fam T
+.fi
+.SH DESCRIPTION
+irunner is an interface to the various interactive runners
+available in IPython's \fBirunner\fP module. 
+.PP
+The already implemented runners are listed below; adding
+one for a new program is a trivial task, see the source
+for examples.
+.SH OPTIONS
+.TP
+.B
+\-h, \-\-help
+show this help message and exit
+.TP
+.B
+\-\-ipython
+IPython interactive runner (default).
+.TP
+.B
+\-\-python
+Python interactive runner.
+.TP
+.B
+\-\-sage
+SAGE interactive runner.
+.SH EXAMPLE
+irunner.py \-\-python \-\- \-\-help
+will pass \-\-help to the python runner.
+Similarly,
+irunner.py \-\-ipython \-\- \-\-interact script.ipy
+.SH SEE ALSO
+.BR ipython(1)
+.br
+.SH BUGS
+The SAGE runner only works if you manually configure your SAGE
+copy to use 'colors NoColor' in the ipythonrc config file, since
+currently the prompt matching regexp does not identify color sequences.
+.SH AUTHOR
+\fBirunner\fP is an extension of Ken Schutte <kschutte-AT-csail.mit.edu>'s
+script contributed on the ipython-user list:
+http://scipy.net/pipermail/ipython-user/2006-May/001705.html
+.PP
+This manual page was written by Bernd Zeimetz <[e-mail]>,
+for the Debian project (but may be used by others).

debian/manpages

@@ -0,0 +1,1 b''
+debian/irunner.1

debian/pycompat

@@ -0,0 +1,1 b''
+2

debian/watch

@@ -0,0 +1,2 b''
+version=3
+http://ipython.scipy.org/dist/ ipython-(.*)\.tar\.gz

doc/do_sphinx.py

@@ -0,0 +1,74 b''
+#!/usr/bin/env python
+"""Script to build documentation using Sphinx.
+"""
+
+import fileinput,os,sys
+
+def oscmd(c):
+    os.system(c)
+
+# html manual.
+oscmd('sphinx-build -d build/doctrees source build/html')
+
+if sys.platform != 'win32':
+    # LaTeX format.
+    oscmd('sphinx-build -b latex -d build/doctrees source build/latex')
+
+    # Produce pdf.
+    topdir = os.getcwd()
+    os.chdir('build/latex')
+
+    # Change chapter style to section style: allows chapters to start on 
+    # the current page.  Works much better for the short chapters we have.
+    # This must go in the class file rather than the preamble, so we modify 
+    # manual.cls at runtime.
+    chapter_cmds=r'''
+% Local changes.
+\renewcommand\chapter{
+    \thispagestyle{plain}
+    \global\@topnum\z@
+    \@afterindentfalse
+    \secdef\@chapter\@schapter
+}
+\def\@makechapterhead#1{
+    \vspace*{10\p@}
+    {\raggedright \reset@font \Huge \bfseries \thechapter \quad #1}
+    \par\nobreak
+    \hrulefill
+    \par\nobreak
+    \vspace*{10\p@}
+}
+\def\@makeschapterhead#1{
+    \vspace*{10\p@}
+    {\raggedright \reset@font \Huge \bfseries #1}
+    \par\nobreak
+    \hrulefill
+    \par\nobreak
+    \vspace*{10\p@}
+}
+'''
+
+    unmodified=True
+    for line in fileinput.FileInput('manual.cls',inplace=1):
+        if 'Support for module synopsis' in line and unmodified:
+            line=chapter_cmds+line
+        elif 'makechapterhead' in line:
+            # Already have altered manual.cls: don't need to again.
+            unmodified=False
+        print line,
+
+    # Copying the makefile produced by sphinx...
+    oscmd('pdflatex ipython.tex')
+    oscmd('pdflatex ipython.tex')
+    oscmd('pdflatex ipython.tex')
+    oscmd('makeindex -s python.ist ipython.idx')
+    oscmd('makeindex -s python.ist modipython.idx')
+    oscmd('pdflatex ipython.tex')
+    oscmd('pdflatex ipython.tex')
+
+    # Create a manual/ directory with final html/pdf output
+    os.chdir(topdir)
+    oscmd('rm -rf manual')
+    oscmd('mkdir manual')
+    oscmd('cp -r build/html/*.html build/html/_static manual/')
+    oscmd('cp build/latex/ipython.pdf manual/')

doc/examples/ipy.vim

@@ -0,0 +1,67 b''
+if !exists("$IPY_SESSION")
+    finish
+endif
+
+" set up the python interpreter within vim, to have all the right modules
+" imported, as well as certain useful globals set
+python import socket
+python import os
+python import vim
+python IPYSERVER = None
+
+python << EOF
+# do we have a connection to the ipython instance?
+def check_server():
+    global IPYSERVER
+    if IPYSERVER:
+        return True
+    else:
+        return False
+
+# connect to the ipython server, if we need to
+def connect():
+    global IPYSERVER
+    if check_server():
+        return
+    try:
+        IPYSERVER = socket.socket(socket.AF_UNIX)
+        IPYSERVER.connect(os.environ.get('IPY_SERVER'))
+    except:
+        IPYSERVER = None
+
+def disconnect():
+    if IPYSERVER:
+        IPYSERVER.close()
+
+def send(cmd):
+    x = 0
+    while True:
+        x += IPYSERVER.send(cmd)
+        if x < len(cmd):
+            cmd = cmd[x:]
+        else:
+            break
+
+def run_this_file():
+    if check_server():
+        send('run %s' % (vim.current.buffer.name,))
+    else:
+        raise Exception, "Not connected to an IPython server"
+EOF
+
+fun! <SID>toggle_send_on_save()
+    if exists("s:ssos") && s:ssos == 1
+        let s:ssos = 0
+        au! BufWritePost *.py :py run_this_file()
+        echo "Autosend Off"
+    else
+        let s:ssos = 1
+        au BufWritePost *.py :py run_this_file()
+        echo "Autowsend On"
+    endif
+endfun
+
+map <silent> <F5> :python run_this_file()<CR>
+imap <silent> <C-F5> <ESC><F5>a
+map <F7> :call <SID>toggle_send_on_save()<CR>
+py connect()

doc/examples/leo_bridge_demo.leo

@@ -0,0 +1,552 b''
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet ekr_test?>
+<leo_file>
+<leo_header file_format="2" tnodes="0" max_tnode_index="0" clone_windows="0"/>
+<globals body_outline_ratio="0.307814992026">
+	<global_window_position top="257" left="131" height="627" width="1280"/>
+	<global_log_window_position top="0" left="0" height="0" width="0"/>
+</globals>
+<preferences/>
+<find_panel_settings/>
+<vnodes>
+<v t="vivainio.20080222193236" a="E"><vh>Documentation</vh>
+<v t="vivainio.20080223121915" tnodeList="vivainio.20080223121915,vivainio.20080222193236.1,vivainio.20080223133858,vivainio.20080223133922,vivainio.20080223133947,vivainio.20080223134018,vivainio.20080223134100,vivainio.20080223134118,vivainio.20080223134433,vivainio.20080223142207,vivainio.20080223134136"><vh>@nosent ILeo_doc.txt</vh>
+<v t="vivainio.20080222193236.1"><vh>Documentation</vh>
+<v t="vivainio.20080223133858"><vh>Introduction</vh></v>
+<v t="vivainio.20080223133922"><vh>Installation</vh></v>
+<v t="vivainio.20080223133947"><vh>Accessing IPython from Leo</vh></v>
+<v t="vivainio.20080223134018"><vh>Accessing Leo nodes from IPython</vh></v>
+<v t="vivainio.20080223134100"><vh>Cl definitions</vh></v>
+<v t="vivainio.20080223134118"><vh>Special node types</vh></v>
+<v t="vivainio.20080223134433"><vh>Custom push</vh></v>
+<v t="vivainio.20080223142207" a="E"><vh>Code snippets</vh></v>
+<v t="vivainio.20080223134136"><vh>Acknowledgements and history</vh></v>
+</v>
+</v>
+</v>
+<v t="vivainio.20080218184525"><vh>@chapters</vh></v>
+<v t="vivainio.20080223133721" a="E"><vh>@settings</vh>
+<v t="vivainio.20080316092617"><vh>@@string ipython_argv = ipython -pylab</vh></v>
+<v t="vivainio.20080223133721.1"><vh>@enabled-plugins</vh></v>
+</v>
+<v t="vivainio.20080218184540"><vh>@ipy-startup</vh>
+<v t="vivainio.20080218184613.1"><vh>b</vh></v>
+<v t="vivainio.20080218200031"><vh>Some classes P</vh>
+<v t="vivainio.20080218190816"><vh>File-like access</vh></v>
+<v t="vivainio.20080218200106"><vh>csv data</vh></v>
+<v t="vivainio.20080219225120"><vh>String list</vh></v>
+<v t="vivainio.20080219230342"><vh>slist to leo</vh></v>
+</v>
+</v>
+<v t="vivainio.20080218195413" a="E"><vh>Class tests</vh>
+<v t="vivainio.20080218200509"><vh>csvr</vh></v>
+<v t="vivainio.20080218191007"><vh>tempfile</vh></v>
+<v t="vivainio.20080218195413.1"><vh>rfile</vh></v>
+<v t="vivainio.20080219225804"><vh>strlist</vh></v>
+</v>
+<v t="vivainio.20080222201226" a="V"><vh>IPython script push tests</vh></v>
+<v t="vivainio.20080218201219" a="E"><vh>Direct variables</vh>
+<v t="vivainio.20080218201219.2"><vh>bar</vh></v>
+</v>
+<v t="vivainio.20080316144536" a="E"><vh>pylab tests</vh>
+<v t="vivainio.20080316145539.2"><vh>Generate testarr</vh></v>
+<v t="vivainio.20080316085925"><vh>testarr</vh></v>
+<v t="vivainio.20080316085950"><vh>Call plotter on testarr</vh></v>
+</v>
+<v t="vivainio.20080222202211"><vh>test stuff</vh></v>
+<v t="vivainio.20080223142403"><vh>@ipy-results</vh>
+<v t="vivainio.20080223142403.1"><vh>foo</vh></v>
+</v>
+<v t="vivainio.20080222202211.1" a="E"><vh>spam</vh></v>
+</vnodes>
+<tnodes>
+<t tx="vivainio.20080218184525">?</t>
+<t tx="vivainio.20080218184540">?Direct children of this node will be pushed at ipython bridge startup
+
+This node itself will *not* be pushed</t>
+<t tx="vivainio.20080218184613.1">print "world"</t>
+<t tx="vivainio.20080218190816">def rfile(body,n):
+    """ @cl rfile 
+
+    produces a StringIO (file like obj of the rest of the body) """
+
+    import StringIO
+    return StringIO.StringIO(body)
+
+def tmpfile(body,n):
+    """ @cl tmpfile
+
+    Produces a temporary file, with node body as contents
+
+    """
+    import tempfile
+    h, fname = tempfile.mkstemp()
+    f = open(fname,'w')
+    f.write(body)
+    f.close()
+    return fname
+</t>
+<t tx="vivainio.20080218191007">@cl tmpfile
+
+Hello</t>
+<t tx="vivainio.20080218195413">?</t>
+<t tx="vivainio.20080218195413.1">@cl rfile
+These
+lines
+should 
+be
+readable </t>
+<t tx="vivainio.20080218200031">@others</t>
+<t tx="vivainio.20080218200106">def csvdata(body,n):
+    import csv
+    d = csv.Sniffer().sniff(body)
+    reader = csv.reader(body.splitlines(), dialect = d)
+    return reader</t>
+<t tx="vivainio.20080218200509">@cl csvdata
+
+a,b,b
+1,2,2</t>
+<t tx="vivainio.20080218201219"></t>
+<t tx="vivainio.20080218201219.2">@cl
+"hello world"</t>
+<t tx="vivainio.20080219225120">import IPython.genutils
+def slist(body,n):
+    return IPython.genutils.SList(body.splitlines())
+</t>
+<t tx="vivainio.20080219225804">@cl slist
+hello
+world
+on
+many
+lines
+</t>
+<t tx="vivainio.20080219230342">import ipy_leo
+@ipy_leo.format_for_leo.when_type(IPython.genutils.SList)
+def format_slist(obj):
+    return "@cl slist\n" + obj.n
+</t>
+<t tx="vivainio.20080222193236">?</t>
+<t tx="vivainio.20080222193236.1">@wrap
+@nocolor</t>
+<t tx="vivainio.20080222201226"># test ipython script 'cleanup' with complex blocks
+1+2
+print "hello"
+3+4
+
+def f(x):
+    return x.upper()
+
+
+if 0:
+    print "foo"
+else:
+    print "bar"
+
+def g():
+    pass
+
+g()
+
+if 1:
+    if 1:
+        print "hello"
+
+        print "world"
+
+if 1:
+    print "hello"
+
+    print "word"
+else:
+    print "foo"
+
+    print "bar"
+    print "baz"
+
+try:
+    raise Exception
+except:
+    print "exc ok"</t>
+<t tx="vivainio.20080222202211"></t>
+<t tx="vivainio.20080222202211.1" ipython="7d71005506636f6f7264737101284b0c4bde747102732e">@cl rfile
+hello
+world
+and whatever</t>
+<t tx="vivainio.20080223121915">@others
+</t>
+<t tx="vivainio.20080223133721"></t>
+<t tx="vivainio.20080223133721.1">ipython.py</t>
+<t tx="vivainio.20080223133858">
+Introduction
+============
+
+The purpose of ILeo, or leo-ipython bridge, is being a two-way communication
+channel between Leo and IPython. The level of integration is much deeper than
+conventional integration in IDEs; most notably, you are able to store *data* in
+Leo nodes, in addition to mere program code. The possibilities of this are
+endless, and this degree of integration has not been seen previously in the python
+world.
+
+IPython users are accustomed to using things like %edit to produce non-trivial
+functions/classes (i.e. something that they don't want to enter directly on the
+interactive prompt, but creating a proper script/module involves too much
+overhead). In ILeo, this task consists just going to the Leo window, creating a node
+and writing the code there, and pressing alt+I (push-to-ipython).
+
+Obviously, you can save the Leo document as usual - this is a great advantage
+of ILeo over using %edit, you can save your experimental scripts all at one
+time, without having to organize them into script/module files (before you
+really want to, of course!)
+</t>
+<t tx="vivainio.20080223133922">
+Installation
+============
+
+You need at least Leo 4.4.7, and the development version of IPython (ILeo
+will be incorporated to IPython 0.8.3).
+
+You can get IPython from Launchpad by installing bzr and doing
+
+bzr branch lp:ipython
+
+and running "setup.py install".
+
+You need to enable the 'ipython.py' plugin in Leo: 
+
+- Help -&gt; Open LeoSettings.leo
+
+- Edit @settings--&gt;Plugins--&gt;@enabled-plugins, add/uncomment 'ipython.py'
+
+- Alternatively, you can add @settings--&gt;@enabled-plugins with body ipython.py to your leo document.
+
+- Restart Leo. Be sure that you have the console window open (start leo.py from console, or double-click leo.py on windows)
+
+- Press alt+5 OR alt-x start-ipython to launch IPython in the console that
+started leo. You can start entering IPython commands normally, and Leo will keep
+running at the same time.
+</t>
+<t tx="vivainio.20080223133947">
+Accessing IPython from Leo
+==========================
+
+IPython code
+------------
+
+Just enter IPython commands on a Leo node and press alt-I to execute
+push-to-ipython in order to execute the script in IPython. 'commands' is
+interpreted loosely here - you can enter function and class definitions, in
+addition to the things you would usually enter at IPython prompt - calculations,
+system commands etc.
+
+Everything that would be legal to enter on IPython prompt is legal to execute
+from ILeo.
+
+Results will be shows in Leo log window for convenience, in addition to the console.
+
+Suppose that a node had the following contents:
+{{{
+1+2
+print "hello"
+3+4
+
+def f(x):
+    return x.upper()
+
+f('hello world')
+}}}
+
+If you press alt+I on that node, you will see the following in Leo log window (IPython tab):
+
+{{{
+In: 1+2
+&lt;2&gt; 3
+In: 3+4
+&lt;4&gt; 7
+In: f('hello world')
+&lt;6&gt; 'HELLO WORLD'
+}}}
+
+(numbers like &lt;6&gt; mean IPython output history indices; the actual object can be
+referenced with _6 as usual in IPython).
+
+
+Plain Python code
+-----------------
+
+If the headline of the node ends with capital P, alt-I will not run the code
+through IPython translation mechanism but use the direct python 'exec' statement
+(in IPython user namespace) to execute the code. It wont be shown in IPython
+history, and sometimes it is safer (and more efficient) to execute things as
+plain Python statements. Large class definitions are good candidates for P
+nodes.
+</t>
+<t tx="vivainio.20080223134018">
+Accessing Leo nodes from IPython
+================================
+
+The real fun starts when you start entering text to leo nodes, and are using
+that as data (input/output) for your IPython work.
+
+Accessing Leo nodes happens through the variable 'wb' (short for "WorkBook")
+that exist in the IPython user namespace. Nodes that are directly accessible are
+the ones that have simple names which could also be Python variable names;
+'foo_1' will be accessible directly from IPython, whereas 'my scripts' will not.
+If you want to access a node with arbitrary headline, add a child node '@a foo'
+(@a stands for 'anchor'). Then, the parent of '@a foo' is accessible through
+'wb.foo'.
+
+You can see what nodes are accessible be entering (in IPython) wb.&lt;TAB&gt;. Example:
+
+[C:leo/src]|12&gt; wb.
+wb.b           wb.tempfile    wb.rfile       wb.NewHeadline
+wb.bar         wb.Docs        wb.strlist     wb.csvr    
+[C:leo/src]|12&gt; wb.tempfile
+           &lt;12&gt; &lt;ipy_leo.LeoNode object at 0x044B6D90&gt;
+
+So here, we meet the 'LeoNode' class that is your key to manipulating Leo
+content from IPython!
+
+LeoNode
+-------
+
+Suppose that we had a node with headline 'spam' and body: 
+
+['12',2222+32]
+
+we can access it from IPython (or from scripts entered into other Leo nodes!) by doing:
+
+C:leo/src]|19&gt; wb.spam.v
+          &lt;19&gt; ['12', 2254]
+
+'v' attribute stands for 'value', which means the node contents will be run
+through 'eval' and everything you would be able to enter into IPython prompt
+will be converted to objects. This mechanism can be extended far beyond direct
+evaluation (see '@cl definitions').
+
+'v' attribute also has a setter, i.e. you can do:
+
+wb.spam.v = "mystring"
+
+Which will result in the node 'spam' having the following text:
+
+'mystring'
+
+What assignment to 'v' does can be configured through generic functions
+('simplegeneric' module, will be explained later).
+
+Besides v, you can set the body text directly through 
+
+wb.spam.b = "some\nstring", 
+
+headline by 
+
+wb.spam.h = 'new_headline' 
+
+(obviously you must access the node through wb.new_headline from that point
+onwards), and access the contents as string list (IPython SList) through
+'wb.spam.l'.
+
+If you do 'wb.foo.v = 12' when node named 'foo' does not exist, the node titled
+'foo' will be automatically created and assigned body 12.
+
+LeoNode also supports go() that focuses the node in the Leo window, and ipush()
+that simulates pressing alt+I on the node.
+
+You can access unknownAttributes by .uA property dictionary. Unknown attributes
+allow you to store arbitrary (pickleable) python objects in the Leo nodes; the
+attributes are stored when you save the .leo document, and recreated when you
+open the document again. The attributes are not visible anywhere, but can be
+used for domain-specific metatada. Example:
+
+    [C:leo/src]|12&gt; wb.spam.uA['coords'] = (12,222)
+    [C:leo/src]|13&gt; wb.spam.uA
+               &lt;13&gt; {'coords': (12, 222)}    
+
+Accessing children with iteration and dict notation
+---------------------------------------------------
+
+Sometimes, you may want to treat a node as a 'database', where the nodes
+children represent elements in the database. You can create a new child node for
+node 'spam', with headline 'foo bar' like this:
+
+    wb.spam['foo bar'] = "Hello"
+
+And assign a new value for it by doing 
+
+    wb.spam['foo bar'].v = "Hello again"
+
+Note how you can't use .v when you first create the node - i.e. the node needs
+to be initialized by simple assignment, that will be interpreted as assignment
+to '.v'. This is a conscious design choice.
+
+If you try to do wb.spam['bar'] = 'Hello', ILeo will assign '@k bar' as the
+headline for the child instead, because 'bar' is a legal python name (and as
+such would be incorporated in the workbook namespace). This is done to avoid
+crowding the workbook namespace with extraneous items. The item will still be
+accessible as wb.spam['bar']
+
+LeoNodes are iterable, so to see the headlines of all the children of 'spam' do:
+
+    for n in wb.spam:
+        print n.h
+</t>
+<t tx="vivainio.20080223134100">
+@cl definitions
+===============
+
+If the first line in the body text is of the form '@cl sometext', IPython will
+evaluate 'sometext' and call the result with the rest of the body when you do
+'wb.foo.v'. An example is in place here. Suppose that we have defined a class (I
+use the term class in a non-python sense here)
+
+{{{
+def rfile(body,node):
+    """ @cl rfile 
+
+    produces a StringIO (file like obj) of the rest of the body """
+
+    import StringIO
+    return StringIO.StringIO(body)
+}}}
+
+(note that node is ignored here - but it could be used to access headline,
+children etc.),
+
+Now, let's say you have node 'spam' with text
+
+{{{
+@cl rfile
+hello
+world
+and whatever
+}}}
+
+Now, in IPython, we can do this:
+
+{{{    
+[C:leo/src]|22&gt; f = wb.spam.v
+[C:leo/src]|23&gt; f
+           &lt;23&gt; &lt;StringIO.StringIO instance at 0x04E7E490&gt;
+[C:leo/src]|24&gt; f.readline()
+           &lt;24&gt; u'hello\n'
+[C:leo/src]|25&gt; f.readline()
+           &lt;25&gt; u'world\n'
+[C:leo/src]|26&gt; f.readline()
+           &lt;26&gt; u'and whatever'
+[C:leo/src]|27&gt; f.readline()
+           &lt;27&gt; u''    
+}}} 
+
+You should declare new @cl types to make ILeo as convenient your problem domain
+as possible. For example, a "@cl etree" could return the elementtree object for
+xml content.
+</t>
+<t tx="vivainio.20080223134118">
+Special node types
+==================
+
+@ipy-startup
+------------
+
+If this node exist, the *direct children* of this will be pushed to IPython when
+ILeo is started (you press alt+5). Use it to push your own @cl definitions etc.
+The contents of of the node itself will be ignored.
+
+@ipy-results
+------------
+
+When you create a new node (wb.foo.v = 'stuff'), the node foo will be created as
+a child of this node. If @ipy-results does not exist, the new node will be created after the currently selected node.
+
+@a nodes
+--------
+
+You can attach these as children of existing nodes to provide a way to access
+nodes with arbitrary headlines, or to provide aliases to other nodes. If
+multiple @a nodes are attached as children of a node, all the names can be used
+to access the same object.
+</t>
+<t tx="vivainio.20080223134136">
+Acknowledgements &amp; History
+==========================
+
+This idea got started when I (Ville) saw this post by Edward Ream (the author of
+Leo) on IPython developer mailing list:
+
+    http://lists.ipython.scipy.org/pipermail/ipython-dev/2008-January/003551.html
+
+I was using FreeMind as mind mapping software, and so I had an immediate use
+case for Leo (which, incidentally, is superior to FreeMind as mind mapper). The
+wheels started rolling, I got obsessed with the power of this concept
+(everything clicked together), and Edwards excitement paralleled mine.
+Everything was mind-bogglingly easy/trivial, something that is typical of all
+revolutionary technologies (think Python here).
+
+The discussion that "built" ILeo is here:
+    http://sourceforge.net/forum/forum.php?thread_id=1911662&amp;forum_id=10226    
+
+?</t>
+<t tx="vivainio.20080223134433">
+Declaring custom push-to-ipython handlers
+=========================================
+
+Sometimes, you might want to configure what alt+I on a node does. You can do
+that by creating your own push function and expose it using
+ipy_leo.expose_ileo_push(f, priority). The function should check whether the
+node should by handled by the function and raise IPython.ipapi.TryNext if it
+will not do the handling, giving the next function in the chain a chance to see
+whether it should handle the push.
+
+This example would print an uppercase version of node body if the node headline ends
+with U (yes, this is completely useless!):
+
+{{{
+def push_upcase(node):
+    if not node.h.endswith('U'):
+        raise TryNext
+    print node.b.upper()
+
+ipy_leo.expose_ileo_push(push_upcase, 12)
+}}}
+
+(the priority should be between 0-100 - typically, you don't need to care about
+it and can usually omit the argument altogether)
+</t>
+<t tx="vivainio.20080223142207">
+Example code snippets
+=====================
+
+Get list of all headlines of all the nodes in leo:
+
+    [node.h for node in wb]
+
+Create node with headline 'baz', empty body:
+    wb.baz
+
+Create 10 child nodes for baz, where i is headline and 'Hello ' + i is body:       
+
+    for i in range(10):
+        wb.baz[i] = 'Hello %d' % i
+
+
+</t>
+<t tx="vivainio.20080223142403"></t>
+<t tx="vivainio.20080223142403.1">12</t>
+<t tx="vivainio.20080316085925">array([[ 0,  1,  2],
+       [ 3,  4,  5],
+       [ 6,  7,  8],
+       [ 9, 10, 11]])</t>
+<t tx="vivainio.20080316085950"># press alt+i here to plot testarr
+
+plot(wb.testarr.v)</t>
+<t tx="vivainio.20080316092617"></t>
+<t tx="vivainio.20080316144536">Quickstart:
+    easy_install numpy    
+    easy_install matplotlib
+
+Make sure you have '@string ipython-argv = ipython -pylab' in @settings. We currently recommend using TkAgg as the backend (it's also the default)</t>
+<t tx="vivainio.20080316145539.2">#press alt+i here to generate an array for plotter
+
+wb.testarr.v = arange(12).reshape(4,3)</t>
+</tnodes>
+</leo_file>

IPython/Extensions/igrid_help.html

@@ -1,86 +1,86 b''
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-<link rel="stylesheet" href="igrid_help.css" type="text/css" />
-<title>igrid help</title>
-</head>
-<body>
-<h1>igrid help</h1>
-
-
-<h2>Commands</h2>
-
-
-<h3>pick (P)</h3>
-<p>Pick the whole row (object is available as "_")</p>
-
-<h3>pickattr (Shift-P)</h3>
-<p>Pick the attribute under the cursor</p>
-
-<h3>pickallattrs (Shift-C)</h3>
-<p>Pick' the complete column under the cursor (i.e. the attribute under the
-cursor) from all currently fetched objects. These attributes will be returned
-as a list.</p>
-
-<h3>enter (E)</h3>
-<p>Enter the object under the cursor. (what this mean depends on the object
-itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
-
-<h3>enterattr (Shift-E)</h3>
-<p>Enter the attribute under the cursor.</p>
-
-<h3>detail (D)</h3>
-<p>Show a detail view of the object under the cursor. This shows the name,
-type, doc string and value of the object attributes (and it might show more
-attributes than in the list view, depending on the object).</p>
-
-<h3>detailattr (Shift-D)</h3>
-<p>Show a detail view of the attribute under the cursor.</p>
-
-<h3>pickrows (M)</h3>
-<p>Pick multiple selected rows (M)</p>
-
-<h3>pickrowsattr (CTRL-M)</h3>
-<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
-
-<h3>find (CTRL-F)</h3>
-<p>Find text</p>
-
-<h3>find_next (F3)</h3>
-<p>Find next occurrence of the searchtext</p>
-
-<h3>find_previous (Shift-F3)</h3>
-<p>Find previous occurrence of the searchtext </p>
-
-<h3>sortattrasc (V)</h3>
-<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>sortattrdesc (Shift-V)</h3>
-<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>leave (Backspace, DEL, X)</h3>
-<p>Close current tab (and all the tabs to the right of the current one).</h3>
-
-<h3>quit (ESC,Q)</h3>
-<p>Quit igrid and return to the IPython prompt.</p>
-
-
-<h2>Navigation</h2>
-
-
-<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
-
-<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
-
-<h3>Move the cursor one column to the left (&lt;)</h3>
-
-<h3>Move the cursor one column to the right (&gt;)</h3>
-
-<h3>Jump to the first row in the current column (CTRL-Up)</h3>
-
-<h3>Jump to the last row in the current column (CTRL-Down)</h3>
-
-</body>
-</html>
+<?xml version='1.0' encoding='iso-8859-1'?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+<link rel="stylesheet" href="igrid_help.css" type="text/css" />
+<title>igrid help</title>
+</head>
+<body>
+<h1>igrid help</h1>
+
+
+<h2>Commands</h2>
+
+
+<h3>pick (P)</h3>
+<p>Pick the whole row (object is available as "_")</p>
+
+<h3>pickattr (Shift-P)</h3>
+<p>Pick the attribute under the cursor</p>
+
+<h3>pickallattrs (Shift-C)</h3>
+<p>Pick' the complete column under the cursor (i.e. the attribute under the
+cursor) from all currently fetched objects. These attributes will be returned
+as a list.</p>
+
+<h3>enter (E)</h3>
+<p>Enter the object under the cursor. (what this mean depends on the object
+itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
+
+<h3>enterattr (Shift-E)</h3>
+<p>Enter the attribute under the cursor.</p>
+
+<h3>detail (D)</h3>
+<p>Show a detail view of the object under the cursor. This shows the name,
+type, doc string and value of the object attributes (and it might show more
+attributes than in the list view, depending on the object).</p>
+
+<h3>detailattr (Shift-D)</h3>
+<p>Show a detail view of the attribute under the cursor.</p>
+
+<h3>pickrows (M)</h3>
+<p>Pick multiple selected rows (M)</p>
+
+<h3>pickrowsattr (CTRL-M)</h3>
+<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
+
+<h3>find (CTRL-F)</h3>
+<p>Find text</p>
+
+<h3>find_next (F3)</h3>
+<p>Find next occurrence of the searchtext</p>
+
+<h3>find_previous (Shift-F3)</h3>
+<p>Find previous occurrence of the searchtext </p>
+
+<h3>sortattrasc (V)</h3>
+<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>sortattrdesc (Shift-V)</h3>
+<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>leave (Backspace, DEL, X)</h3>
+<p>Close current tab (and all the tabs to the right of the current one).</h3>
+
+<h3>quit (ESC,Q)</h3>
+<p>Quit igrid and return to the IPython prompt.</p>
+
+
+<h2>Navigation</h2>
+
+
+<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
+
+<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
+
+<h3>Move the cursor one column to the left (&lt;)</h3>
+
+<h3>Move the cursor one column to the right (&gt;)</h3>
+
+<h3>Jump to the first row in the current column (CTRL-Up)</h3>
+
+<h3>Jump to the last row in the current column (CTRL-Down)</h3>
+
+</body>
+</html>

IPython/Extensions/ipy_app_completers.py

@@ -14,4 +14,6 b' from ipy_completers import *'
 ip.set_hook('complete_command', apt_completer, re_key = '.*apt-get')
 ip.set_hook('complete_command', svn_completer, str_key = 'svn')
 ip.set_hook('complete_command', hg_completer, str_key = 'hg')
-ip.set_hook('complete_command', bzr_completer, str_key = 'bzr')
+
+# the old bzr completer is deprecated, we recommend ipy_bzr
+#ip.set_hook('complete_command', bzr_completer, str_key = 'bzr')

IPython/Extensions/ipy_completers.py

@@ -1,4 +1,3 b''
-#!/usr/bin/env python
 
 """ Implementations for various useful completers
 
@@ -12,6 +11,7 b' import IPython.ipapi'
 import glob,os,shlex,sys
 import inspect
 from time import time
+from zipimport import zipimporter
 ip = IPython.ipapi.get()
 
 try:
@@ -86,13 +86,18 b' def moduleList(path):'
 
     if os.path.isdir(path):
         folder_list = os.listdir(path)
+    elif path.endswith('.egg'):
+        try:
+            folder_list = [f for f in zipimporter(path)._files]
+        except:
+            folder_list = []
     else:
         folder_list = []
     #folder_list = glob.glob(os.path.join(path,'*'))
     folder_list = [p for p in folder_list  \
        if os.path.exists(os.path.join(path, p,'__init__.py'))\
            or p[-3:] in ('.py','.so')\
-           or p[-4:] in ('.pyc','.pyo')]
+           or p[-4:] in ('.pyc','.pyo','.pyd')]
 
     folder_list = [os.path.basename(p).split('.')[0] for p in folder_list]
     return folder_list
@@ -211,15 +216,15 b' def hg_completer(self,event):'
 
 
 
-bzr_commands = """
-add annotate bind branch break-lock bundle-revisions cat check
-checkout commit conflicts deleted diff export gannotate gbranch
-gcommit gdiff help ignore ignored info init init-repository inventory
-log merge missing mkdir mv nick pull push reconcile register-branch
-remerge remove renames resolve revert revno root serve sign-my-commits
-status testament unbind uncommit unknowns update upgrade version
-version-info visualise whoami
-"""
+__bzr_commands = None
+
+def bzr_commands():
+    global __bzr_commands
+    if __bzr_commands is not None:
+        return __bzr_commands
+    out = os.popen('bzr help commands')
+    __bzr_commands = [l.split()[0] for l in out]
+    return __bzr_commands                
 
 def bzr_completer(self,event):
     """ Completer for bazaar commands """
@@ -232,7 +237,7 b' def bzr_completer(self,event):'
         param = cmd_param[-1]
         output_file = (param == '--output=')
         if cmd == 'help':
-            return bzr_commands.split()
+            return bzr_commands()
         elif cmd in ['bundle-revisions','conflicts',
                      'deleted','nick','register-branch',
                      'serve','unbind','upgrade','version',
@@ -242,7 +247,7 b' def bzr_completer(self,event):'
             # the rest are probably file names
             return ip.IP.Completer.file_matches(event.symbol)
 
-    return bzr_commands.split()
+    return bzr_commands()
 
 
 def shlex_split(x):
@@ -326,7 +331,29 b' def cd_completer(self, event):'
         if os.path.isdir(relpath):
             return [relpath]
         raise IPython.ipapi.TryNext
-    return found
+
+
+    def single_dir_expand(matches):
+        "Recursively expand match lists containing a single dir."
+        
+        if len(matches) == 1 and os.path.isdir(matches[0]):
+            # Takes care of links to directories also.  Use '/'
+            # explicitly, even under Windows, so that name completions
+            # don't end up escaped.
+            d = matches[0]
+            if d[-1] in ['/','\\']:
+                d = d[:-1]
+
+            subdirs = [p for p in os.listdir(d) if os.path.isdir( d + '/' + p)]
+            if subdirs:
+                matches = [ (d + '/' + p) for p in subdirs ]
+                return single_dir_expand(matches)
+            else:
+                return matches
+        else:
+            return matches
+
+    return single_dir_expand(found)
 
 def apt_get_packages(prefix):
     out = os.popen('apt-cache pkgnames')

IPython/Extensions/ipy_leo.py

@@ -1,248 +1,592 b''
-""" Leo plugin for IPython
-
-Example use:
-
-nodes.foo = "hello world"
-
-  -> create '@ipy foo' node with text "hello world"
-
-Access works also, and so does tab completion.
-   
-"""
-import IPython.ipapi
-import IPython.genutils
-import IPython.generics
-import re
-
-
-
-ip = IPython.ipapi.get()
-leo = ip.user_ns['leox']
-c,g = leo.c, leo.g
-
-# will probably be overwritten by user, but handy for experimentation early on
-ip.user_ns['c'] = c
-ip.user_ns['g'] = g
-
-
-from IPython.external.simplegeneric import generic 
-import pprint
-
-@generic
-def format_for_leo(obj):
-    """ Convert obj to string representiation (for editing in Leo)"""
-    return pprint.pformat(obj)
-
-@format_for_leo.when_type(list)
-def format_list(obj):
-    return "\n".join(str(s) for s in obj)
-
-nodename_re = r'(@ipy?[\w-]+)?\s?(\w+)'
-
-def all_cells():
-    d = {}
-    for p in c.allNodes_iter():
-        h = p.headString()
-        if h.startswith('@') and len(h.split()) == 1: 
-            continue
-        mo = re.match(nodename_re, h)
-        if not mo:
-            continue
-        d[mo.group(2)] = p.copy()
-    return d    
-    
-
-class TrivialLeoWorkbook:
-    """ class to find cells with simple syntax
-    
-    """
-    def __getattr__(self, key):
-        cells = all_cells()
-        p = cells[key]
-        body = p.bodyString()
-        return eval_body(body)
-    def __setattr__(self,key,val):
-        cells = all_cells()
-        p = cells.get(key,None)
-        if p is None:
-            add_var(key,val)
-        else:
-            c.setBodyString(p,format_for_leo(val))
-    def __str__(self):
-        return "<TrivialLeoWorkbook>"
-    __repr__ = __str__
-
-ip.user_ns['nodes'] = TrivialLeoWorkbook()            
-
-
-class LeoNode(object):
-    def __init__(self,p):
-        self.p = p.copy()
-
-    def get_h(self): return self.p.headString()
-    def set_h(self,val):
-        print "set head",val
-        c.beginUpdate() 
-        try:
-            c.setHeadString(self.p,val)
-        finally:
-            c.endUpdate()
-        
-    h = property( get_h, set_h)  
-
-    def get_b(self): return self.p.bodyString()
-    def set_b(self,val):
-        print "set body",val
-        c.beginUpdate()
-        try: 
-            c.setBodyString(self.p, val)
-        finally:
-            c.endUpdate()
-    
-    b = property(get_b, set_b)
-    
-    def set_val(self, val):
-        self.b = pprint.pformat(val)
-        
-    v = property(lambda self: ip.ev(self.b.strip()), set_val)
-    
-    def set_l(self,val):
-        self.b = '\n'.join(val )
-    l = property(lambda self : IPython.genutils.SList(self.b.splitlines()), 
-                 set_l)
-    
-    def __iter__(self):
-        return (LeoNode(p) for p in self.p.children_iter())
-     
-
-class LeoWorkbook:
-    """ class for 'advanced' node access """
-    def __getattr__(self, key):
-        if key.startswith('_') or key == 'trait_names':
-            raise AttributeError
-        cells = all_cells()
-        p = cells.get(key, None)
-        if p is None:
-            p = add_var(key,None)
-
-        return LeoNode(p)
-
-    def __str__(self):
-        return "<LeoWorkbook>"
-    __repr__ = __str__
-ip.user_ns['wb'] = LeoWorkbook()
-
-
-_dummyval = object()
[e-mail]_object.when_type(LeoWorkbook)
-def workbook_complete(obj, prev):
-    return all_cells().keys()
-    
-
-def add_var(varname, value = _dummyval):
-    c.beginUpdate()
-    try:
-        
-        nodename = '@ipy-var ' + varname
-        p2 = g.findNodeAnywhere(c,nodename)
-        if not c.positionExists(p2):
-            p2 = c.currentPosition().insertAfter()
-            c.setHeadString(p2,'@ipy ' + varname)
-            
-        c.setCurrentPosition(p2)
-        if value is _dummyval:
-            val = ip.user_ns[varname]
-        else:
-            val = value
-        if val is not None:
-            formatted = format_for_leo(val)
-            c.setBodyString(p2,formatted)
-        return p2
-    finally:
-        c.endUpdate()
-
-def add_file(self,fname):
-    p2 = c.currentPosition().insertAfter()
-
-def push_script(p):
-    c.beginUpdate()
-    try:
-        ohist = ip.IP.output_hist 
-        hstart = len(ip.IP.input_hist)
-        script = g.getScript(c,p,useSelectedText=False,forcePythonSentinels=False,useSentinels=False)
-        
-        script = g.splitLines(script + '\n')
-        script = ''.join(z for z in script if z.strip())
-        
-        ip.runlines(script)
-        
-        has_output = False
-        for idx in range(hstart,len(ip.IP.input_hist)):
-            val = ohist.get(idx,None)
-            if val is None:
-                continue
-            has_output = True
-            inp = ip.IP.input_hist[idx]
-            if inp.strip():
-                g.es('In: %s' % (inp[:40], ),  tabName = 'IPython')
-                
-            g.es('<%d> %s' % (idx, pprint.pformat(ohist[idx],width = 40)), tabName = 'IPython')
-        
-        if not has_output:
-            g.es('ipy run: %s' %( p.headString(),), tabName = 'IPython')
-    finally:
-        c.endUpdate()
-    
-    
-def eval_body(body):
-    try:
-        val = ip.ev(body)
-    except:
-        # just use stringlist if it's not completely legal python expression
-        val = IPython.genutils.SList(body.splitlines())
-    return val 
-    
-def push_variable(p,varname):
-    body = p.bodyString()
-    val = eval_body(body.strip())
-    ip.user_ns[varname] = val
-    g.es('ipy var: %s' % (varname,), tabName = "IPython")
-    
-def push_from_leo(p):    
-    tup = p.headString().split(None,1)
-    # @ipy foo is variable foo
-    if len(tup) == 2 and tup[0] == '@ipy':
-        varname = tup[1]
-        push_variable(p,varname)
-        return
-
-    push_script(p)
-    return
-    
-    
-ip.user_ns['leox'].push = push_from_leo    
-    
-def leo_f(self,s):
-    """ open file(s) in Leo
-    
-    Takes an mglob pattern, e.g. '%leo *.cpp' or %leo 'rec:*.cpp'  
-    """
-    import os
-    from IPython.external import mglob
-    
-    files = mglob.expand(s)
-    c.beginUpdate()
-    try:
-        for fname in files:
-            p = g.findNodeAnywhere(c,'@auto ' + fname)
-            if not p:
-                p = c.currentPosition().insertAfter()
-            
-            p.setHeadString('@auto ' + fname)
-            if os.path.isfile(fname):
-                c.setBodyString(p,open(fname).read())
-            c.selectPosition(p)
-    finally:
-        c.endUpdate()
-
-ip.expose_magic('leo',leo_f)
+""" ILeo - Leo plugin for IPython
+
+   
+"""
+import IPython.ipapi
+import IPython.genutils
+import IPython.generics
+from IPython.hooks import CommandChainDispatcher
+import re
+import UserDict
+from IPython.ipapi import TryNext 
+import IPython.macro
+import IPython.Shell
+
+def init_ipython(ipy):
+    """ This will be run by _ip.load('ipy_leo') 
+    
+    Leo still needs to run update_commander() after this.
+    
+    """
+    global ip
+    ip = ipy
+    IPython.Shell.hijack_tk()
+    ip.set_hook('complete_command', mb_completer, str_key = '%mb')
+    ip.expose_magic('mb',mb_f)
+    ip.expose_magic('lee',lee_f)
+    ip.expose_magic('leoref',leoref_f)
+    expose_ileo_push(push_cl_node,100)
+    # this should be the LAST one that will be executed, and it will never raise TryNext
+    expose_ileo_push(push_ipython_script, 1000)
+    expose_ileo_push(push_plain_python, 100)
+    expose_ileo_push(push_ev_node, 100)
+    global wb
+    wb = LeoWorkbook()
+    ip.user_ns['wb'] = wb 
+    
+    show_welcome()
+
+
+def update_commander(new_leox):
+    """ Set the Leo commander to use
+    
+    This will be run every time Leo does ipython-launch; basically,
+    when the user switches the document he is focusing on, he should do
+    ipython-launch to tell ILeo what document the commands apply to.
+    
+    """
+    
+    global c,g
+    c,g = new_leox.c, new_leox.g
+    print "Set Leo Commander:",c.frame.getTitle()
+    
+    # will probably be overwritten by user, but handy for experimentation early on
+    ip.user_ns['c'] = c
+    ip.user_ns['g'] = g
+    ip.user_ns['_leo'] = new_leox
+    
+    new_leox.push = push_position_from_leo
+    run_leo_startup_node()
+
+from IPython.external.simplegeneric import generic 
+import pprint
+
+def es(s):    
+    g.es(s, tabName = 'IPython')
+    pass
+
+@generic
+def format_for_leo(obj):
+    """ Convert obj to string representiation (for editing in Leo)"""
+    return pprint.pformat(obj)
+
+@format_for_leo.when_type(list)
+def format_list(obj):
+    return "\n".join(str(s) for s in obj)
+  
+
+attribute_re = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
+def valid_attribute(s):
+    return attribute_re.match(s)    
+
+_rootnode = None
+def rootnode():
+    """ Get ileo root node (@ipy-root) 
+    
+    if node has become invalid or has not been set, return None
+    
+    Note that the root is the *first* @ipy-root item found    
+    """
+    global _rootnode
+    if _rootnode is None:
+        return None
+    if c.positionExists(_rootnode.p):
+        return _rootnode
+    _rootnode = None
+    return None  
+
+def all_cells():
+    global _rootnode
+    d = {}
+    r = rootnode() 
+    if r is not None:
+        nodes = r.p.children_iter()
+    else:
+        nodes = c.allNodes_iter()
+
+    for p in nodes:
+        h = p.headString()
+        if h.strip() == '@ipy-root':
+            # update root node (found it for the first time)
+            _rootnode = LeoNode(p)            
+            # the next recursive call will use the children of new root
+            return all_cells()
+        
+        if h.startswith('@a '):
+            d[h.lstrip('@a ').strip()] = p.parent().copy()
+        elif not valid_attribute(h):
+            continue 
+        d[h] = p.copy()
+    return d    
+
+def eval_node(n):
+    body = n.b    
+    if not body.startswith('@cl'):
+        # plain python repr node, just eval it
+        return ip.ev(n.b)
+    # @cl nodes deserve special treatment - first eval the first line (minus cl), then use it to call the rest of body
+    first, rest = body.split('\n',1)
+    tup = first.split(None, 1)
+    # @cl alone SPECIAL USE-> dump var to user_ns
+    if len(tup) == 1:
+        val = ip.ev(rest)
+        ip.user_ns[n.h] = val
+        es("%s = %s" % (n.h, repr(val)[:20]  )) 
+        return val
+
+    cl, hd = tup 
+
+    xformer = ip.ev(hd.strip())
+    es('Transform w/ %s' % repr(xformer))
+    return xformer(rest, n)
+
+class LeoNode(object, UserDict.DictMixin):
+    """ Node in Leo outline
+    
+    Most important attributes (getters/setters available:
+     .v     - evaluate node, can also be alligned 
+     .b, .h - body string, headline string
+     .l     - value as string list
+    
+    Also supports iteration, 
+    
+    setitem / getitem (indexing):  
+     wb.foo['key'] = 12
+     assert wb.foo['key'].v == 12
+    
+    Note the asymmetry on setitem and getitem! Also other
+    dict methods are available. 
+    
+    .ipush() - run push-to-ipython
+
+    Minibuffer command access (tab completion works):
+    
+     mb save-to-file
+    
+    """
+    def __init__(self,p):
+        self.p = p.copy()
+
+    def __str__(self):
+        return "<LeoNode %s>" % str(self.p)
+    
+    __repr__ = __str__
+    
+    def __get_h(self): return self.p.headString()
+    def __set_h(self,val):
+        print "set head",val
+        c.beginUpdate() 
+        try:
+            c.setHeadString(self.p,val)
+        finally:
+            c.endUpdate()
+        
+    h = property( __get_h, __set_h, doc = "Node headline string")  
+
+    def __get_b(self): return self.p.bodyString()
+    def __set_b(self,val):
+        print "set body",val
+        c.beginUpdate()
+        try: 
+            c.setBodyString(self.p, val)
+        finally:
+            c.endUpdate()
+    
+    b = property(__get_b, __set_b, doc = "Nody body string")
+    
+    def __set_val(self, val):        
+        self.b = format_for_leo(val)
+        
+    v = property(lambda self: eval_node(self), __set_val, doc = "Node evaluated value")
+    
+    def __set_l(self,val):
+        self.b = '\n'.join(val )
+    l = property(lambda self : IPython.genutils.SList(self.b.splitlines()), 
+                 __set_l, doc = "Node value as string list")
+    
+    def __iter__(self):
+        """ Iterate through nodes direct children """
+        
+        return (LeoNode(p) for p in self.p.children_iter())
+
+    def __children(self):
+        d = {}
+        for child in self:
+            head = child.h
+            tup = head.split(None,1)
+            if len(tup) > 1 and tup[0] == '@k':
+                d[tup[1]] = child
+                continue
+            
+            if not valid_attribute(head):
+                d[head] = child
+                continue
+        return d
+    def keys(self):
+        d = self.__children()
+        return d.keys()
+    def __getitem__(self, key):
+        """ wb.foo['Some stuff'] Return a child node with headline 'Some stuff'
+        
+        If key is a valid python name (e.g. 'foo'), look for headline '@k foo' as well
+        """  
+        key = str(key)
+        d = self.__children()
+        return d[key]
+    def __setitem__(self, key, val):
+        """ You can do wb.foo['My Stuff'] = 12 to create children 
+        
+        This will create 'My Stuff' as a child of foo (if it does not exist), and 
+        do .v = 12 assignment.
+        
+        Exception:
+        
+        wb.foo['bar'] = 12
+        
+        will create a child with headline '@k bar', because bar is a valid python name
+        and we don't want to crowd the WorkBook namespace with (possibly numerous) entries
+        """
+        key = str(key)
+        d = self.__children()
+        if key in d:
+            d[key].v = val
+            return
+        
+        if not valid_attribute(key):
+            head = key
+        else:
+            head = '@k ' + key
+        p = c.createLastChildNode(self.p, head, '')
+        LeoNode(p).v = val
+        
+    def ipush(self):
+        """ Does push-to-ipython on the node """
+        push_from_leo(self)
+        
+    def go(self):
+        """ Set node as current node (to quickly see it in Outline) """
+        c.beginUpdate()
+        try:
+            c.setCurrentPosition(self.p)
+        finally:
+            c.endUpdate()  
+        
+    def script(self):
+        """ Method to get the 'tangled' contents of the node
+        
+        (parse @others, << section >> references etc.)
+        """
+        return g.getScript(c,self.p,useSelectedText=False,useSentinels=False)
+    
+    def __get_uA(self):
+        p = self.p
+        # Create the uA if necessary.
+        if not hasattr(p.v.t,'unknownAttributes'):
+            p.v.t.unknownAttributes = {}        
+        
+        d = p.v.t.unknownAttributes.setdefault('ipython', {})
+        return d        
+    
+    uA = property(__get_uA, doc = "Access persistent unknownAttributes of node")
+        
+
+class LeoWorkbook:
+    """ class for 'advanced' node access 
+    
+    Has attributes for all "discoverable" nodes. Node is discoverable if it 
+    either
+    
+    - has a valid python name (Foo, bar_12)
+    - is a parent of an anchor node (if it has a child '@a foo', it is visible as foo)
+    
+    """
+    def __getattr__(self, key):
+        if key.startswith('_') or key == 'trait_names' or not valid_attribute(key):
+            raise AttributeError
+        cells = all_cells()
+        p = cells.get(key, None)
+        if p is None:
+            return add_var(key)
+
+        return LeoNode(p)
+
+    def __str__(self):
+        return "<LeoWorkbook>"
+    def __setattr__(self,key, val):
+        raise AttributeError("Direct assignment to workbook denied, try wb.%s.v = %s" % (key,val))
+        
+    __repr__ = __str__
+    
+    def __iter__(self):
+        """ Iterate all (even non-exposed) nodes """
+        cells = all_cells()
+        return (LeoNode(p) for p in c.allNodes_iter())
+    
+    current = property(lambda self: LeoNode(c.currentPosition()), doc = "Currently selected node")
+    
+    def match_h(self, regex):
+        cmp = re.compile(regex)
+        for node in self:
+            if re.match(cmp, node.h, re.IGNORECASE):
+                yield node
+        return
+
[e-mail]_object.when_type(LeoWorkbook)
+def workbook_complete(obj, prev):
+    return all_cells().keys() + [s for s in prev if not s.startswith('_')]
+    
+
+def add_var(varname):
+    c.beginUpdate()
+    r = rootnode()
+    try:
+        if r is None:
+            p2 = g.findNodeAnywhere(c,varname)
+        else:
+            p2 = g.findNodeInChildren(c, r.p, varname)
+        if p2:
+            return LeoNode(p2)
+
+        if r is not None:
+            p2 = r.p.insertAsLastChild()
+        
+        else:
+            p2 =  c.currentPosition().insertAfter()
+        
+        c.setHeadString(p2,varname)
+        return LeoNode(p2)
+    finally:
+        c.endUpdate()
+
+def add_file(self,fname):
+    p2 = c.currentPosition().insertAfter()
+
+push_from_leo = CommandChainDispatcher()
+
+def expose_ileo_push(f, prio = 0):
+    push_from_leo.add(f, prio)
+
+def push_ipython_script(node):
+    """ Execute the node body in IPython, as if it was entered in interactive prompt """
+    c.beginUpdate()
+    try:
+        ohist = ip.IP.output_hist 
+        hstart = len(ip.IP.input_hist)
+        script = node.script()
+                
+        ip.user_ns['_p'] = node
+        ip.runlines(script)
+        ip.user_ns.pop('_p',None)
+        
+        has_output = False
+        for idx in range(hstart,len(ip.IP.input_hist)):
+            val = ohist.get(idx,None)
+            if val is None:
+                continue
+            has_output = True
+            inp = ip.IP.input_hist[idx]
+            if inp.strip():
+                es('In: %s' % (inp[:40], ))
+                
+            es('<%d> %s' % (idx, pprint.pformat(ohist[idx],width = 40)))
+        
+        if not has_output:
+            es('ipy run: %s (%d LL)' %( node.h,len(script)))
+    finally:
+        c.endUpdate()
+
+    
+def eval_body(body):
+    try:
+        val = ip.ev(body)
+    except:
+        # just use stringlist if it's not completely legal python expression
+        val = IPython.genutils.SList(body.splitlines())
+    return val 
+    
+def push_plain_python(node):
+    if not node.h.endswith('P'):
+        raise TryNext
+    script = node.script()
+    lines = script.count('\n')
+    try:
+        exec script in ip.user_ns
+    except:
+        print " -- Exception in script:\n"+script + "\n --"
+        raise
+    es('ipy plain: %s (%d LL)' % (node.h,lines))
+    
+
+def push_cl_node(node):
+    """ If node starts with @cl, eval it
+    
+    The result is put as last child of @ipy-results node, if it exists
+    """
+    if not node.b.startswith('@cl'):
+        raise TryNext
+        
+    p2 = g.findNodeAnywhere(c,'@ipy-results')
+    val = node.v
+    if p2:
+        es("=> @ipy-results")
+        LeoNode(p2).v = val
+    es(val)
+
+def push_ev_node(node):
+    """ If headline starts with @ev, eval it and put result in body """
+    if not node.h.startswith('@ev '):
+        raise TryNext
+    expr = node.h.lstrip('@ev ')
+    es('ipy eval ' + expr)
+    res = ip.ev(expr)
+    node.v = res
+    
+    
+def push_position_from_leo(p):
+    try:
+        push_from_leo(LeoNode(p))
+    except AttributeError,e:
+        if e.args == ("Commands instance has no attribute 'frame'",):
+            es("Error: ILeo not associated with .leo document")
+            es("Press alt+shift+I to fix!")
+        else:
+            raise
+
+@generic
+def edit_object_in_leo(obj, varname):
+    """ Make it @cl node so it can be pushed back directly by alt+I """
+    node = add_var(varname)
+    formatted = format_for_leo(obj)
+    if not formatted.startswith('@cl'):
+        formatted = '@cl\n' + formatted
+    node.b = formatted 
+    node.go()
+    
+@edit_object_in_leo.when_type(IPython.macro.Macro)
+def edit_macro(obj,varname):
+    bod = '_ip.defmacro("""\\\n' + obj.value + '""")'
+    node = add_var('Macro_' + varname)
+    node.b = bod
+    node.go()
+
+def get_history(hstart = 0):
+    res = []
+    ohist = ip.IP.output_hist 
+
+    for idx in range(hstart, len(ip.IP.input_hist)):
+        val = ohist.get(idx,None)
+        has_output = True
+        inp = ip.IP.input_hist_raw[idx]
+        if inp.strip():
+            res.append('In [%d]: %s' % (idx, inp))
+        if val:
+            res.append(pprint.pformat(val))
+            res.append('\n')    
+    return ''.join(res)
+    
+    
+def lee_f(self,s):
+    """ Open file(s)/objects in Leo
+    
+    - %lee hist -> open full session history in leo
+    - Takes an object. l = [1,2,"hello"]; %lee l. Alt+I in leo pushes the object back
+    - Takes an mglob pattern, e.g. '%lee *.cpp' or %lee 'rec:*.cpp'
+    - Takes input history indices:  %lee 4 6-8 10 12-47
+    """
+    import os
+        
+    c.beginUpdate()
+    try:
+        if s == 'hist':
+            wb.ipython_history.b = get_history()
+            wb.ipython_history.go()
+            return
+        
+            
+        if s and s[0].isdigit():
+            # numbers; push input slices to leo
+            lines = self.extract_input_slices(s.strip().split(), True)
+            v = add_var('stored_ipython_input')
+            v.b = '\n'.join(lines)
+            return
+            
+        
+        # try editing the object directly
+        obj = ip.user_ns.get(s, None)
+        if obj is not None:
+            edit_object_in_leo(obj,s)
+            return
+     
+        
+        # if it's not object, it's a file name / mglob pattern
+        from IPython.external import mglob
+        
+        files = (os.path.abspath(f) for f in mglob.expand(s))
+        for fname in files:
+            p = g.findNodeAnywhere(c,'@auto ' + fname)
+            if not p:
+                p = c.currentPosition().insertAfter()
+            
+            p.setHeadString('@auto ' + fname)
+            if os.path.isfile(fname):
+                c.setBodyString(p,open(fname).read())
+            c.selectPosition(p)
+        print "Editing file(s), press ctrl+shift+w in Leo to write @auto nodes"
+    finally:
+        c.endUpdate()
+
+
+
+def leoref_f(self,s):
+    """ Quick reference for ILeo """
+    import textwrap
+    print textwrap.dedent("""\
+    %leoe file/object - open file / object in leo
+    wb.foo.v  - eval node foo (i.e. headstring is 'foo' or '@ipy foo')
+    wb.foo.v = 12 - assign to body of node foo
+    wb.foo.b - read or write the body of node foo
+    wb.foo.l - body of node foo as string list
+    
+    for el in wb.foo:
+      print el.v
+       
+    """
+    )
+
+
+
+def mb_f(self, arg):
+    """ Execute leo minibuffer commands 
+    
+    Example:
+     mb save-to-file
+    """
+    c.executeMinibufferCommand(arg)
+
+def mb_completer(self,event):
+    """ Custom completer for minibuffer """
+    cmd_param = event.line.split()
+    if event.line.endswith(' '):
+        cmd_param.append('')
+    if len(cmd_param) > 2:
+        return ip.IP.Completer.file_matches(event.symbol)
+    cmds = c.commandsDict.keys()
+    cmds.sort()
+    return cmds
+
+def show_welcome():
+    print "------------------"
+    print "Welcome to Leo-enabled IPython session!"
+    print "Try %leoref for quick reference."
+    import IPython.platutils
+    IPython.platutils.set_term_title('ILeo')
+    IPython.platutils.freeze_term_title()
+
+def run_leo_startup_node():
+    p = g.findNodeAnywhere(c,'@ipy-startup')
+    if p:
+        print "Running @ipy-startup nodes"
+        for n in LeoNode(p):
+            push_from_leo(n)
+            
+

IPython/Extensions/ipy_profile_sh.py

@@ -43,11 +43,13 b' def main():'
     # %store foo
     # %store bar
     import ipy_rehashdir
-    import ipy_signals
+
+    # does not work without subprocess module!
+    #import ipy_signals
     
     ip.ex('import os')
     ip.ex("def up(): os.chdir('..')")
-        
+    ip.user_ns['LA'] = LastArgFinder() 
     # Nice prompt
     
     o.prompt_in1= r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
@@ -117,6 +119,29 b' def main():'
     
     extend_shell_behavior(ip)
 
+class LastArgFinder:
+    """ Allow $LA to work as "last argument of previous command", like $! in bash
+    
+    To call this in normal IPython code, do LA()
+    """
+    def __call__(self, hist_idx = None):
+        ip = ipapi.get()
+        if hist_idx is None:
+            return str(self)
+        return ip.IP.input_hist_raw[hist_idx].strip().split()[-1]
+    def __str__(self):
+        ip = ipapi.get()        
+        for cmd in reversed(ip.IP.input_hist_raw):
+            parts = cmd.strip().split()
+            if len(parts) < 2 or parts[-1] in ['$LA', 'LA()']:
+                continue
+            return parts[-1]
+        return ""
+
+
+
+
+
 # XXX You do not need to understand the next function!
 # This should probably be moved out of profile
 

IPython/Extensions/jobctrl.py

@@ -41,8 +41,9 b' Now launch a new IPython prompt and kill the process:'
 (you don't need to specify PID for %kill if only one task is running)
 """                     
 
-from subprocess import Popen,PIPE
+from subprocess import *
 import os,shlex,sys,time
+import threading,Queue
 
 from IPython import genutils
 
@@ -71,15 +72,70 b' def startjob(job):'
     p.line = job
     return p
 
+class AsyncJobQ(threading.Thread):
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.q = Queue.Queue()
+        self.output = []
+        self.stop = False
+    def run(self):
+        while 1:
+            cmd,cwd = self.q.get()
+            if self.stop:
+                self.output.append("** Discarding: '%s' - %s" % (cmd,cwd))
+                continue
+            self.output.append("** Task started: '%s' - %s" % (cmd,cwd))
+            
+            p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd = cwd)
+            out = p.stdout.read()
+            self.output.append("** Task complete: '%s'\n" % cmd)
+            self.output.append(out)
+
+    def add(self,cmd):
+        self.q.put_nowait((cmd, os.getcwd()))
+        
+    def dumpoutput(self):
+        while self.output:
+            item = self.output.pop(0)
+            print item            
+
+_jobq = None
+
+def jobqueue_f(self, line):
+     
+    global _jobq
+    if not _jobq:
+        print "Starting jobqueue - do '&some_long_lasting_system_command' to enqueue"
+        _jobq = AsyncJobQ()
+        _jobq.setDaemon(True)
+        _jobq.start()
+        ip.jobq = _jobq.add
+        return
+    if line.strip() == 'stop':
+        print "Stopping and clearing jobqueue, %jobqueue start to start again"
+        _jobq.stop = True
+        return
+    if line.strip() == 'start':
+        _jobq.stop = False
+        return
+        
 def jobctrl_prefilter_f(self,line):    
     if line.startswith('&'):
         pre,fn,rest = self.split_user_input(line[1:])
         
         line = ip.IP.expand_aliases(fn,rest)
-        return '_ip.startjob(%s)' % genutils.make_quoted_expr(line)
+        if not _jobq:
+            return '_ip.startjob(%s)' % genutils.make_quoted_expr(line)
+        return '_ip.jobq(%s)' % genutils.make_quoted_expr(line)
 
     raise IPython.ipapi.TryNext
 
+def jobq_output_hook(self):
+    if not _jobq:
+        return
+    _jobq.dumpoutput()
+
+
 
 def job_list(ip):
     keys = ip.db.keys('tasks/*')
@@ -91,8 +147,16 b' def magic_tasks(self,line):'
 
     A 'task' is a process that has been started in IPython when 'jobctrl' extension is enabled.
     Tasks can be killed with %kill.
+    
+    '%tasks clear' clears the task list (from stale tasks)
     """
     ip = self.getapi()
+    if line.strip() == 'clear':
+        for k in ip.db.keys('tasks/*'):
+            print "Clearing",ip.db[k]
+            del ip.db[k]
+        return
+        
     ents = job_list(ip)
     if not ents:
         print "No tasks running"
@@ -125,7 +189,7 b' def magic_kill(self,line):'
         magic_tasks(self,line)
         
 if sys.platform == 'win32':
-    shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir time 	type ver vol'.split()
+    shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir start time type ver vol'.split()
 else:
     # todo linux commands
     shell_internal_commands = [] 
@@ -133,20 +197,33 b' else:'
 
 def jobctrl_shellcmd(ip,cmd):
     """ os.system replacement that stores process info to db['tasks/t1234'] """
+    cmd = cmd.strip()
     cmdname = cmd.split(None,1)[0]
-    if cmdname in shell_internal_commands:
+    if cmdname in shell_internal_commands or '|' in cmd or '>' in cmd or '<' in cmd:
         use_shell = True
     else:
         use_shell = False
 
-    p = Popen(cmd,shell = use_shell)
-    jobentry = 'tasks/t' + str(p.pid)
-    
+    jobentry = None
     try:
+        try:
+            p = Popen(cmd,shell = use_shell)
+        except WindowsError:
+            if use_shell:
+                # try with os.system
+                os.system(cmd)
+                return
+            else:
+                # have to go via shell, sucks
+                p = Popen(cmd,shell = True)
+            
+        jobentry = 'tasks/t' + str(p.pid)
         ip.db[jobentry] = (p.pid,cmd,os.getcwd(),time.time())
-        p.communicate()
+        p.communicate()        
+
     finally:
-        del ip.db[jobentry]
+        if jobentry:
+            del ip.db[jobentry]
 
 
 def install():
@@ -158,5 +235,6 b' def install():'
     ip.set_hook('shell_hook', jobctrl_shellcmd)
     ip.expose_magic('kill',magic_kill)
     ip.expose_magic('tasks',magic_tasks)
-    
+    ip.expose_magic('jobqueue',jobqueue_f)
+    ip.set_hook('pre_prompt_hook', jobq_output_hook) 
 install()

IPython/Itpl.py

@@ -94,8 +94,16 b' def matchorfail(text, pos):'
     match = tokenprog.match(text, pos)
     if match is None:
         raise ItplError(text, pos)
+
     return match, match.end()
 
+try:
+    itpl_encoding = sys.stdin.encoding or 'ascii'
+except AttributeError:
+    itpl_encoding = 'ascii'
+
+    
+
 class Itpl:
     """Class representing a string with interpolation abilities.
     
@@ -104,7 +112,7 b' class Itpl:'
     evaluation and substitution happens in the namespace of the
     caller when str(instance) is called."""
 
-    def __init__(self, format,codec=sys.stdin.encoding,encoding_errors='backslashreplace'):
+    def __init__(self, format,codec=itpl_encoding,encoding_errors='backslashreplace'):
         """The single mandatory argument to this constructor is a format
         string.
 

IPython/Magic.py

@@ -115,9 +115,9 b' class Magic:'
 
     def profile_missing_notice(self, *args, **kwargs):
         error("""\
-The profile module could not be found.  If you are a Debian user,
-it has been removed from the standard Debian package because of its non-free
-license. To use profiling, please install"python2.3-profiler" from non-free.""")
+The profile module could not be found. It has been removed from the standard
+python packages because of its non-free license. To use profiling, install the
+python-profiler package from non-free.""")
 
     def default_option(self,fn,optstr):
         """Make an entry in the options_table for fn, with value optstr"""
@@ -147,7 +147,7 b' license. To use profiling, please install"python2.3-profiler" from non-free.""")'
                  filter(inst_magic,self.__dict__.keys()) + \
                  filter(inst_bound_magic,self.__class__.__dict__.keys())
         out = []
-        for fn in magics:
+        for fn in Set(magics):
             out.append(fn.replace('magic_','',1))
         out.sort()
         return out
@@ -386,7 +386,10 b' license. To use profiling, please install"python2.3-profiler" from non-free.""")'
         return None
         
     def magic_magic(self, parameter_s = ''):
-        """Print information about the magic function system."""
+        """Print information about the magic function system.
+        
+        Supported formats: -latex, -brief, -rest        
+        """
 
         mode = ''
         try:
@@ -394,6 +397,9 b' license. To use profiling, please install"python2.3-profiler" from non-free.""")'
                 mode = 'latex'
             if parameter_s.split()[0] == '-brief':
                 mode = 'brief'
+            if parameter_s.split()[0] == '-rest':
+                mode = 'rest'
+                rest_docs = []
         except:
             pass
 
@@ -409,14 +415,26 b' license. To use profiling, please install"python2.3-profiler" from non-free.""")'
                     break
             if mode == 'brief':
                 # only first line
-                fndoc = fn.__doc__.split('\n',1)[0]
+                if fn.__doc__:                    
+                    fndoc = fn.__doc__.split('\n',1)[0]
+                else:
+                    fndoc = 'No documentation'
+            else:
+                fndoc = fn.__doc__.rstrip()
+                
+            if mode == 'rest':
+                rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(self.shell.ESC_MAGIC,
+                                                    fname,fndoc))
+                
             else:
-                fndoc = fn.__doc__
+                magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
+                                                    fname,fndoc))
                 
-            magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
-                                                fname,fndoc))
         magic_docs = ''.join(magic_docs)
 
+        if mode == 'rest':
+            return "".join(rest_docs)
+        
         if mode == 'latex':
             print self.format_latex(magic_docs)
             return
@@ -2612,7 +2630,7 b' Defaulting color scheme to \'NoColor\'"""'
                     os.chdir(pdir)
                     for ff in os.listdir(pdir):
                         base, ext = os.path.splitext(ff)
-                        if isexec(ff) and base not in self.shell.no_alias:
+                        if isexec(ff) and base.lower() not in self.shell.no_alias:
                             if ext.lower() == '.exe':
                                 ff = base
                             alias_table[base.lower()] = (0,ff)
@@ -2667,6 +2685,7 b' Defaulting color scheme to \'NoColor\'"""'
         parameter_s = parameter_s.strip()
         #bkms = self.shell.persist.get("bookmarks",{})
 
+        oldcwd = os.getcwd()
         numcd = re.match(r'(-)(\d+)$',parameter_s)
         # jump in directory history by number
         if numcd:
@@ -2705,7 +2724,7 b' Defaulting color scheme to \'NoColor\'"""'
             
         # at this point ps should point to the target dir
         if ps:
-            try:
+            try:                
                 os.chdir(os.path.expanduser(ps))
                 if self.shell.rc.term_title:
                     #print 'set term title:',self.shell.rc.term_title  # dbg
@@ -2716,8 +2735,9 b' Defaulting color scheme to \'NoColor\'"""'
             else:
                 cwd = os.getcwd()
                 dhist = self.shell.user_ns['_dh']
-                dhist.append(cwd)
-                self.db['dhist'] = compress_dhist(dhist)[-100:]
+                if oldcwd != cwd:
+                    dhist.append(cwd)
+                    self.db['dhist'] = compress_dhist(dhist)[-100:]
                 
         else:
             os.chdir(self.shell.home_dir)
@@ -2725,8 +2745,10 b' Defaulting color scheme to \'NoColor\'"""'
                 platutils.set_term_title("IPy ~")
             cwd = os.getcwd()
             dhist = self.shell.user_ns['_dh']
-            dhist.append(cwd)
-            self.db['dhist'] = compress_dhist(dhist)[-100:]
+            
+            if oldcwd != cwd:
+                dhist.append(cwd)
+                self.db['dhist'] = compress_dhist(dhist)[-100:]
         if not 'q' in opts and self.shell.user_ns['_dh']:
             print self.shell.user_ns['_dh'][-1]
 
@@ -3118,7 +3140,7 b' Defaulting color scheme to \'NoColor\'"""'
              screen_lines=self.shell.rc.screen_length)
 
     def magic_cpaste(self, parameter_s=''):
-        """Allows you to paste & execute a pre-formatted code block from clipboard
+        """Allows you to paste & execute a pre-formatted code block from clipboard.
         
         You must terminate the block with '--' (two minus-signs) alone on the
         line. You can also provide your own sentinel with '%paste -s %%' ('%%' 
@@ -3126,13 +3148,14 b' Defaulting color scheme to \'NoColor\'"""'
         
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
-        ignored, to allow pasting directly from e-mails or diff files. The
+        ignored, to allow pasting directly from e-mails, diff files and
+        doctests (the '...' continuation prompt is also stripped).  The
         executed block is also assigned to variable named 'pasted_block' for
         later editing with '%edit pasted_block'.
         
         You can also pass a variable name as an argument, e.g. '%cpaste foo'.
         This assigns the pasted block to variable 'foo' as string, without 
-        dedenting or executing it.
+        dedenting or executing it (preceding >>> and + is still stripped)
         
         Do not be alarmed by garbled output on Windows (it's a readline bug). 
         Just press enter and type -- (and press enter again) and the block 
@@ -3143,6 +3166,15 b' Defaulting color scheme to \'NoColor\'"""'
         opts,args = self.parse_options(parameter_s,'s:',mode='string')
         par = args.strip()
         sentinel = opts.get('s','--')
+
+        # Regular expressions that declare text we strip from the input:
+        strip_re =  [r'^\s*In \[\d+\]:', # IPython input prompt
+                     r'^\s*(\s?>)+', # Python input prompt
+                     r'^\s*\.{3,}', # Continuation prompts
+                     r'^\++',
+                     ]
+
+        strip_from_start = map(re.compile,strip_re)
         
         from IPython import iplib
         lines = []
@@ -3151,7 +3183,11 b' Defaulting color scheme to \'NoColor\'"""'
             l = iplib.raw_input_original(':')
             if l ==sentinel:
                 break
-            lines.append(l.lstrip('>').lstrip('+'))
+            
+            for pat in strip_from_start: 
+                l = pat.sub('',l)
+            lines.append(l)
+                         
         block = "\n".join(lines) + '\n'
         #print "block:\n",block
         if not par:

IPython/OInspect.py

@@ -404,7 +404,13 b' class Inspector:'
         # Filename where object was defined
         binary_file = False
         try:
-            fname = inspect.getabsfile(obj)
+            try:
+                fname = inspect.getabsfile(obj)
+            except TypeError:
+                # For an instance, the file that matters is where its class was
+                # declared.
+                if hasattr(obj,'__class__'):
+                    fname = inspect.getabsfile(obj.__class__)
             if fname.endswith('<string>'):
                 fname = 'Dynamically generated function. No source code available.'
             if (fname.endswith('.so') or fname.endswith('.dll')):
@@ -432,8 +438,13 b' class Inspector:'
             linecache.checkcache()
             source_success = False
             try:
-                source = self.format(getsource(obj,binary_file))
-                if source:
+                try:
+                    src = getsource(obj,binary_file)
+                except TypeError:
+                    if hasattr(obj,'__class__'):
+                        src = getsource(obj.__class__,binary_file)
+                if src is not None:
+                    source = self.format(src)
                     out.write(header('Source:\n')+source.rstrip())
                     source_success = True
             except Exception, msg:

IPython/Release.py

@@ -22,9 +22,15 b" name = 'ipython'"
 # because bdist_rpm does not accept dashes (an RPM) convention, and
 # bdist_deb does not accept underscores (a Debian convention).
 
-revision = '3001'
+revision = '128'
+branch = 'ipython'
 
-version = '0.8.3.svn.r' + revision.rstrip('M')
+if branch == 'ipython':
+    version = '0.8.4.bzr.r' + revision
+else:
+    version = '0.8.4.bzr.r%s.%s'  % (revision,branch)
+
+version = '0.8.4'
 
 description = "An enhanced interactive Python shell."
 

IPython/Shell.py

@@ -46,6 +46,13 b' from IPython.ipmaker import make_IPython'
 from IPython.Magic import Magic
 from IPython.ipstruct import Struct
 
+try: # Python 2.3 compatibility
+    set
+except NameError:
+    import sets
+    set = sets.Set
+
+
 # Globals
 # global flag to pass around information about Ctrl-C without exceptions
 KBINT = False
@@ -358,36 +365,37 b' class MTInteractiveShell(InteractiveShell):'
         InteractiveShell.__init__(self,name,usage,rc,user_ns,
                                   user_global_ns,banner2)
 
-        # Locking control variable.
-        self.thread_ready = threading.Condition(threading.RLock())
 
-        # A queue to hold the code to be executed.  A scalar variable is NOT
-        # enough, because uses like macros cause reentrancy.
+        # A queue to hold the code to be executed. 
         self.code_queue = Queue.Queue()
 
         # Stuff to do at closing time
-        self._kill = False
-        on_kill = kw.get('on_kill')
-        if on_kill is None:
-            on_kill = []
+        self._kill = None
+        on_kill = kw.get('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
-
+        # thread identity of the "worker thread" (that may execute code directly)
+        self.worker_ident = None
+        
     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
+
+        if self._kill:
+            # can't queue new code if we are being killed
+            return True
         
         try:
             code = self.compile(source, filename, symbol)
@@ -400,29 +408,40 b' class MTInteractiveShell(InteractiveShell):'
             # Case 2
             return True
 
+        # shortcut - if we are in worker thread, or the worker thread is not running, 
+        # execute directly (to allow recursion and prevent deadlock if code is run early 
+        # in IPython construction)
+        
+        if (self.worker_ident is None or self.worker_ident == thread.get_ident()):
+            InteractiveShell.runcode(self,code)
+            return
+
         # Case 3
         # Store code in queue, so the execution thread can handle it.
 
-        # Note that with macros and other applications, we MAY re-enter this
-        # section, so we have to acquire the lock with non-blocking semantics,
-        # else we deadlock.
-        got_lock = self.thread_ready.acquire()
-        self.code_queue.put(code)
-        if got_lock:
-           self.thread_ready.wait()  # Wait until processed in timeout interval
-        self.thread_ready.release()
-
+        completed_ev, received_ev = threading.Event(), threading.Event() 
+        
+        self.code_queue.put((code,completed_ev, received_ev))
+        # first make sure the message was received, with timeout
+        received_ev.wait(5)
+        if not received_ev.isSet():
+            # the mainloop is dead, start executing code directly
+            print "Warning: Timeout for mainloop thread exceeded"
+            print "switching to nonthreaded mode (until mainloop wakes up again)"
+            self.worker_ident = None
+        else:
+            completed_ev.wait()
         return False
 
     def runcode(self):
         """Execute a code object.
 
         Multithreaded wrapper around IPython's runcode()."""
-
+        
         global CODE_RUN
-
-        # lock thread-protected stuff
-        got_lock = self.thread_ready.acquire()
+        
+        # we are in worker thread, stash out the id for runsource() 
+        self.worker_ident = thread.get_ident()
 
         if self._kill:
             print >>Term.cout, 'Closing threads...',
@@ -430,6 +449,9 b' class MTInteractiveShell(InteractiveShell):'
             for tokill in self.on_kill:
                 tokill()
             print >>Term.cout, 'Done.'
+            # allow kill() to return
+            self._kill.set()
+            return True
 
         # Install sigint handler.  We do it every time to ensure that if user
         # code modifies it, we restore our own handling.
@@ -445,10 +467,11 b' class MTInteractiveShell(InteractiveShell):'
         code_to_run = None
         while 1:
             try:
-                code_to_run = self.code_queue.get_nowait()
+                code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()                
             except Queue.Empty:
                 break
-
+            received_ev.set()
+            
             # Exceptions need to be raised differently depending on which
             # thread is active.  This convoluted try/except is only there to
             # protect against asynchronous exceptions, to ensure that a KBINT
@@ -462,28 +485,23 b' class MTInteractiveShell(InteractiveShell):'
                 except KeyboardInterrupt:
                    print "Keyboard interrupted in mainloop"
                    while not self.code_queue.empty():
-                      self.code_queue.get_nowait()
+                      code, ev1,ev2 = self.code_queue.get_nowait()
+                      ev1.set()
+                      ev2.set()                      
                    break
             finally:
-               if got_lock:
-                  CODE_RUN = False
-
-        # We're done with thread-protected variables
-        if code_to_run is not None:
-           self.thread_ready.notify()
-        self.thread_ready.release()
-
-        # We're done...
-        CODE_RUN = False
+                CODE_RUN = False
+                # allow runsource() return from wait
+                completed_ev.set()
+                
+        
         # This MUST return true for gtk threading to work
         return True
 
     def kill(self):
         """Kill the thread, returning when it has been shut down."""
-        got_lock = self.thread_ready.acquire(False)
-        self._kill = True
-        if got_lock:
-            self.thread_ready.release()
+        self._kill = threading.Event()
+        self._kill.wait()
 
 class MatplotlibShellBase:
     """Mixin class to provide the necessary modifications to regular IPython
@@ -1051,7 +1069,9 b' def _load_pylab(user_ns):'
     
     ip = IPython.ipapi.get()
     if ip.options.pylab_import_all:
-        exec "from matplotlib.pylab import *" in user_ns
+        ip.ex("from matplotlib.pylab import *")
+        ip.IP.user_config_ns.update(ip.user_ns)
+        
 
 class IPShellMatplotlib(IPShell):
     """Subclass IPShell with MatplotlibShell as the internal shell.
@@ -1144,7 +1164,7 b' def _select_shell(argv):'
     all_opts = set(['tk','pylab','gthread','qthread','q4thread','wthread',
                     'tkthread'])
     user_opts = set([s.replace('-','') for s in argv[:3]])
-    special_opts = user_opts & all_opts
+    special_opts = user_opts & all_opts            
 
     if 'tk' in special_opts:
         USE_TK = True

IPython/UserConfig/ipy_user_conf.py

@@ -72,6 +72,27 b' def main():'
     #o.autoexec.append('%colors NoColor')
     #o.autoexec.append('%colors Linux')
     
+    # for sane integer division that converts to float (1/2 == 0.5)
+    #o.autoexec.append('from __future__ import division')
+    
+    # For %tasks and %kill
+    #import jobctrl 
+    
+    # For autoreloading of modules (%autoreload, %aimport)    
+    #import ipy_autoreload
+    
+    # For winpdb support (%wdb)
+    #import ipy_winpdb
+    
+    # For bzr completer, requires bzrlib (the python installation of bzr)
+    #ip.load('ipy_bzr')
+    
+    # Tab completer that is not quite so picky (i.e. 
+    # "foo".<TAB> and str(2).<TAB> will work). Complete 
+    # at your own risk!
+    #import ipy_greedycompleter
+    
+    
     
 # some config helper functions you can use 
 def import_all(modules):

IPython/completer.py

@@ -321,7 +321,7 b' class IPCompleter(Completer):'
         # don't want to treat as delimiters in filename matching
         # when escaped with backslash
 
-        protectables = ' ()[]{}'
+        protectables = ' '
 
         if text.startswith('!'):
             text = text[1:]

IPython/deep_reload.py

@@ -32,7 +32,9 b' import imp'
 import sys
 
 # Replacement for __import__()
-def deep_import_hook(name, globals=None, locals=None, fromlist=None):
+def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
+    # For now level is ignored, it's just there to prevent crash  
+    # with from __future__ import absolute_import
     parent = determine_parent(globals)
     q, tail = find_head_package(parent, name)
     m = load_tail(q, tail)

IPython/external/mglob.py

@@ -34,35 +34,35 b' License: MIT Open Source license'
 #Assigned in variable for "usage" printing convenience"
 
 globsyntax = """\
-This program allows specifying filenames with "mglob" mechanism.
-Supported syntax in globs (wilcard matching patterns)::
-
- *.cpp ?ellowo*                
-     - obvious. Differs from normal glob in that dirs are not included.
-       Unix users might want to write this as: "*.cpp" "?ellowo*"
- rec:/usr/share=*.txt,*.doc    
-     - get all *.txt and *.doc under /usr/share, 
-       recursively
- rec:/usr/share
-     - All files under /usr/share, recursively
- rec:*.py
-     - All .py files under current working dir, recursively
- foo                           
-     - File or dir foo
- !*.bak readme*                   
-     - readme*, exclude files ending with .bak
- !.svn/ !.hg/ !*_Data/ rec:.
-     - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
-       Trailing / is the key, \ does not work!
- dir:foo                       
-     - the directory foo if it exists (not files in foo)
- dir:*                         
-     - all directories in current folder
- foo.py bar.* !h* rec:*.py
-     - Obvious. !h* exclusion only applies for rec:*.py.
-       foo.py is *not* included twice.
- @filelist.txt
-     - All files listed in 'filelist.txt' file, on separate lines.
+    This program allows specifying filenames with "mglob" mechanism.
+    Supported syntax in globs (wilcard matching patterns)::
+    
+     *.cpp ?ellowo*                
+         - obvious. Differs from normal glob in that dirs are not included.
+           Unix users might want to write this as: "*.cpp" "?ellowo*"
+     rec:/usr/share=*.txt,*.doc    
+         - get all *.txt and *.doc under /usr/share, 
+           recursively
+     rec:/usr/share
+         - All files under /usr/share, recursively
+     rec:*.py
+         - All .py files under current working dir, recursively
+     foo                           
+         - File or dir foo
+     !*.bak readme*                   
+         - readme*, exclude files ending with .bak
+     !.svn/ !.hg/ !*_Data/ rec:.
+         - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
+           Trailing / is the key, \ does not work!
+     dir:foo                       
+         - the directory foo if it exists (not files in foo)
+     dir:*                         
+         - all directories in current folder
+     foo.py bar.* !h* rec:*.py
+         - Obvious. !h* exclusion only applies for rec:*.py.
+           foo.py is *not* included twice.
+     @filelist.txt
+         - All files listed in 'filelist.txt' file, on separate lines.
  """
 
 

IPython/external/path.py

@@ -29,7 +29,10 b' Date: 9 Mar 2007'
 
 from __future__ import generators
 
-import sys, warnings, os, fnmatch, glob, shutil, codecs, md5
+import sys, warnings, os, fnmatch, glob, shutil, codecs
+# deprecated in python 2.6
+warnings.filterwarnings('ignore', r'.*md5.*')
+import md5
 
 __version__ = '2.2'
 __all__ = ['path']

IPython/genutils.py

@@ -22,7 +22,10 b' __license__ = Release.license'
 # required modules from the Python standard library
 import __main__
 import commands
-import doctest
+try:
+    import doctest
+except ImportError:
+    pass
 import os
 import re
 import shlex
@@ -33,6 +36,18 b' import time'
 import types
 import warnings
 
+# Curses and termios are Unix-only modules
+try:
+    import curses
+    # We need termios as well, so if its import happens to raise, we bail on
+    # using curses altogether.
+    import termios
+except ImportError:
+    USE_CURSES = False
+else:
+    # Curses on Solaris may not be complete, so we can't use it there
+    USE_CURSES = hasattr(curses,'initscr')
+
 # Other IPython utilities
 import IPython
 from IPython.Itpl import Itpl,itpl,printpl
@@ -1052,25 +1067,40 b' class SList(list):'
     
     p = paths = property(get_paths)
 
-    def grep(self, pattern, prune = False):
+    def grep(self, pattern, prune = False, field = None):
         """ Return all strings matching 'pattern' (a regex or callable) 
         
         This is case-insensitive. If prune is true, return all items
         NOT matching the pattern.
         
+        If field is specified, the match must occur in the specified 
+        whitespace-separated field.
+               
         Examples::
         
             a.grep( lambda x: x.startswith('C') )
             a.grep('Cha.*log', prune=1)
+            a.grep('chm', field=-1)
         """
+        
+        def match_target(s):
+            if field is None:
+                return s
+            parts = s.split()
+            try:
+                tgt = parts[field]
+                return tgt
+            except IndexError:
+                return ""
+        
         if isinstance(pattern, basestring):
             pred = lambda x : re.search(pattern, x, re.IGNORECASE)
         else:
             pred = pattern
         if not prune:
-            return SList([el for el in self if pred(el)])
+            return SList([el for el in self if pred(match_target(el))])
         else:
-            return SList([el for el in self if not pred(el)])
+            return SList([el for el in self if not pred(match_target(el))])
     def fields(self, *fields):
         """ Collect whitespace-separated fields from string list
         
@@ -1083,6 +1113,7 b' class SList(list):'
         a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
         a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
         (note the joining by space).
+        a.fields(-1) is ['ChangeLog', 'IPython']
         
         IndexErrors are ignored.
         
@@ -1532,26 +1563,30 b' def page(strng,start=0,screen_lines=0,pager_cmd = None):'
     # auto-determine screen size
     if screen_lines <= 0:
         if TERM=='xterm':
-            try:
-                import curses
-                if hasattr(curses,'initscr'):
-                    use_curses = 1
-                else:
-                    use_curses = 0
-            except ImportError:
-                use_curses = 0
+            use_curses = USE_CURSES
         else:
             # curses causes problems on many terminals other than xterm.
-            use_curses = 0
+            use_curses = False
         if use_curses:
-                scr = curses.initscr()
-                screen_lines_real,screen_cols = scr.getmaxyx()
-                curses.endwin()
-                screen_lines += screen_lines_real
-                #print '***Screen size:',screen_lines_real,'lines x',\
-                #screen_cols,'columns.' # dbg
+            # There is a bug in curses, where *sometimes* it fails to properly
+            # initialize, and then after the endwin() call is made, the
+            # terminal is left in an unusable state.  Rather than trying to
+            # check everytime for this (by requesting and comparing termios
+            # flags each time), we just save the initial terminal state and
+            # unconditionally reset it every time.  It's cheaper than making
+            # the checks.
+            term_flags = termios.tcgetattr(sys.stdout)
+            scr = curses.initscr()
+            screen_lines_real,screen_cols = scr.getmaxyx()
+            curses.endwin()
+            # Restore terminal state in case endwin() didn't.
+            termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
+            # Now we have what we needed: the screen size in rows/columns
+            screen_lines += screen_lines_real
+            #print '***Screen size:',screen_lines_real,'lines x',\
+            #screen_cols,'columns.' # dbg
         else:
-                screen_lines += screen_lines_def
+            screen_lines += screen_lines_def
 
     #print 'numlines',numlines,'screenlines',screen_lines  # dbg
     if numlines <= screen_lines :

IPython/gui/wx/ipython_history.py

@@ -28,10 +28,30 b' class IPythonHistoryPanel(wx.Panel):'
         self.filter_cmd   = wx.CheckBox(self, -1, "!: Sys commands")
         self.filter_magic = wx.CheckBox(self, -1, "%: Magic keys")
 
-        self.filter_empty.SetValue(flt_empty)
-        self.filter_doc.SetValue(flt_doc)
-        self.filter_cmd.SetValue(flt_cmd)
-        self.filter_magic.SetValue(flt_magic)
+        self.options={'filter_empty':{'value':'True',
+                                      'checkbox':self.filter_empty,'True':True,'False':False,
+                                      'setfunc':lambda x:None},
+                      'filter_doc':{'value':'True',
+                                    'checkbox':self.filter_doc,'True':True,'False':False,
+                                    'setfunc':lambda x:None},
+                      'filter_cmd':{'value':'True',
+                                    'checkbox':self.filter_cmd,'True':True,'False':False,
+                                    'setfunc':lambda x:None},
+                      'filter_magic':{'value':'True',
+                                      'checkbox':self.filter_magic,'True':True,'False':False,
+                                      'setfunc':lambda x:None},
+                     }
+        self.reloadOptions(self.options)
+
+        self.filter_empty.Bind(wx.EVT_CHECKBOX, self.evtCheckEmptyFilter)
+        self.filter_doc.Bind(wx.EVT_CHECKBOX, self.evtCheckDocFilter)
+        self.filter_cmd.Bind(wx.EVT_CHECKBOX, self.evtCheckCmdFilter)
+        self.filter_magic.Bind(wx.EVT_CHECKBOX, self.evtCheckMagicFilter)
+        
+        #self.filter_empty.SetValue(flt_empty)
+        #self.filter_doc.SetValue(flt_doc)
+        #self.filter_cmd.SetValue(flt_cmd)
+        #self.filter_magic.SetValue(flt_magic)
         
         sizer = wx.BoxSizer(wx.VERTICAL)
 
@@ -70,10 +90,54 b' class IPythonHistoryPanel(wx.Panel):'
                 add = False
             if self.filter_magic.GetValue() == True and history_line[0] == '%':
                 add = False
-	if add:
-        	self.text_ctrl.AppendText(history_line+'\n')
+        if add:
+                self.text_ctrl.AppendText(history_line+'\n')
+
+#------------------------ Option Section -----------------------------------
+    def processOptionCheckedEvt(self, event, name):
+        if event.IsChecked():
+            self.options[name]['value']='True'
+        else:
+            self.options[name]['value']='False'
+        self.updateOptionTracker(name,
+                                 self.options[name]['value'])
+        
+    def evtCheckEmptyFilter(self, event):
+        self.processOptionCheckedEvt(event, 'filter_empty')
+        
+    def evtCheckDocFilter(self, event):
+        self.processOptionCheckedEvt(event, 'filter_doc')
 
+    def evtCheckCmdFilter(self, event):
+        self.processOptionCheckedEvt(event, 'filter_cmd')
 
+    def evtCheckMagicFilter(self, event):
+        self.processOptionCheckedEvt(event, 'filter_magic')
+        
+    def getOptions(self):
+        return self.options
+    
+    def reloadOptions(self,options):
+        self.options = options
+        for key in self.options.keys():
+            value = self.options[key]['value']
+            self.options[key]['checkbox'].SetValue(self.options[key][value])
+            self.options[key]['setfunc'](value)
+
+#------------------------ Hook Section -----------------------------------
+    def updateOptionTracker(self,name,value):
+        '''
+        Default history tracker (does nothing)
+        '''
+        pass
+    
+    def setOptionTrackerHook(self,func):
+        '''
+        Define a new history tracker
+        '''
+        self.updateOptionTracker = func
+
+            
 #----------------------------------------------------------------------
 # Font definition for Styled Text Control
 

IPython/gui/wx/ipython_view.py

@@ -1,7 +1,7 b''
 #!/usr/bin/python
 # -*- coding: iso-8859-15 -*-
 '''
-Provides IPython WX console widget.
+Provides IPython WX console widgets.
 
 @author: Laurent Dufrechou
 laurent.dufrechou _at_ gmail.com
@@ -26,433 +26,88 b' __license__ = "BSD"'
 
 import wx
 import wx.stc  as  stc
-import wx.lib.newevent
 
 import re
 import sys
-import os
 import locale
-import time
-from ThreadEx import Thread
 from StringIO import StringIO
-
 try:
         import IPython
 except Exception,e:
         raise "Error importing IPython (%s)" % str(e)
 
-class IterableIPShell(Thread):
+from ipshell_nonblocking import NonBlockingIPShell
+
+class WxNonBlockingIPShell(NonBlockingIPShell):
     '''
-    Create an IPython instance inside a dedicated thread.
-    Does not start a blocking event loop, instead allow single iterations.
-    This allows embedding in any GUI without blockage.
-    The thread is a slave one, in that it doesn't interact directly with the GUI.
-    Note Thread class comes from ThreadEx that supports asynchroneous function call
-    via raise_exc()
+    An NonBlockingIPShell Thread that is WX dependent.
     '''
-
-    def __init__(self,argv=[],user_ns=None,user_global_ns=None,
+    def __init__(self, parent, 
+                 argv=[],user_ns={},user_global_ns=None,
                  cin=None, cout=None, cerr=None,
-                 exit_handler=None,time_loop = 0.1):
-        '''
-        @param argv: Command line options for IPython
-        @type argv: list
-        @param user_ns: User namespace.
-        @type user_ns: dictionary
-        @param user_global_ns: User global namespace.
-        @type user_global_ns: dictionary.
-        @param cin: Console standard input.
-        @type cin: IO stream
-        @param cout: Console standard output.
-        @type cout: IO stream
-        @param cerr: Console standard error.
-        @type cerr: IO stream
-        @param exit_handler: Replacement for builtin exit() function
-        @type exit_handler: function
-        @param time_loop: Define the sleep time between two thread's loop
-        @type int
-        '''
-        Thread.__init__(self)
-
-        #first we redefine in/out/error functions of IPython 
-        if cin:
-            IPython.Shell.Term.cin = cin
-        if cout:
-            IPython.Shell.Term.cout = cout
-        if cerr:
-            IPython.Shell.Term.cerr = cerr
-        
-        # This is to get rid of the blockage that accurs during
-        # IPython.Shell.InteractiveShell.user_setup()
-        IPython.iplib.raw_input = lambda x: None
-
-        self._term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)
-
-        excepthook = sys.excepthook
-        self._IP = IPython.Shell.make_IPython(
-                                            argv,user_ns=user_ns,
-                                            user_global_ns=user_global_ns,
-                                            embedded=True,
-                                            shell_class=IPython.Shell.InteractiveShell)
-
-        #we replace IPython default encoding by wx locale encoding
-	loc = locale.getpreferredencoding()
-	if loc:
-        	self._IP.stdin_encoding = loc
-        #we replace the ipython default pager by our pager
-        self._IP.set_hook('show_in_pager',self._pager)
-        
-        #we replace the ipython default shell command caller by our shell handler
-	self._IP.set_hook('shell_hook',self._shell)
-        
-        #we replace the ipython default input command caller by our method
-        IPython.iplib.raw_input_original = self._raw_input
-        #we replace the ipython default exit command by our method
-        self._IP.exit = self._setAskExit
-            
-        sys.excepthook = excepthook
-
-        self._iter_more = 0
-        self._history_level = 0
-        self._complete_sep =  re.compile('[\s\{\}\[\]\(\)]')
-        self._prompt = str(self._IP.outputcache.prompt1).strip()
-
-        #thread working vars
-        self._terminate = False
-        self._time_loop = time_loop
-        self._has_doc = False
-        self._do_execute = False
-        self._line_to_execute = ''
-        self._doc_text = None
-        self._ask_exit = False
-
-    #----------------------- Thread management section ----------------------    
-    def run (self):
-        """
-        Thread main loop
-        The thread will run until self._terminate will be set to True via shutdown() function
-        Command processing can be interrupted with Instance.raise_exc(KeyboardInterrupt) call in the
-        GUI thread.
-        """
-        while(not self._terminate):
-            try:
-                if self._do_execute:
-                    self._doc_text = None
-                    self._execute()
-                    self._do_execute = False
-                
-            except KeyboardInterrupt:
-                pass
-
-            time.sleep(self._time_loop)
-            
-    def shutdown(self): 
-        """
-        Shutdown the tread
-        """
-        self._terminate = True
-
-    def doExecute(self,line):
-        """
-        Tell the thread to process the 'line' command
-        """
-        self._do_execute = True
-        self._line_to_execute = line
-        
-    def isExecuteDone(self):
-        """
-        Returns the processing state
-        """
-        return not self._do_execute
-
-    #----------------------- IPython management section ----------------------    
-    def getAskExit(self):
-        '''
-        returns the _ask_exit variable that can be checked by GUI to see if
-        IPython request an exit handling
-        '''
-        return self._ask_exit
-
-    def clearAskExit(self):
-        '''
-        clear the _ask_exit var when GUI as handled the request.
-        '''
-        self._ask_exit = False
-        
-    def getDocText(self):
-        """
-        Returns the output of the processing that need to be paged (if any)
-
-        @return: The std output string.
-        @rtype: string
-        """
-        return self._doc_text
-        
-    def getBanner(self):
-        """
-        Returns the IPython banner for useful info on IPython instance
-
-        @return: The banner string.
-        @rtype: string
-        """
-        return self._IP.BANNER
-    
-    def getPromptCount(self):
-        """
-        Returns the prompt number.
-        Each time a user execute a line in the IPython shell the prompt count is increased
-
-        @return: The prompt number
-        @rtype: int
-        """
-        return self._IP.outputcache.prompt_count
-
-    def getPrompt(self):
-        """
-        Returns current prompt inside IPython instance
-        (Can be In [...]: ot ...:)
-
-        @return: The current prompt.
-        @rtype: string
-        """
-        return self._prompt
-
-    def getIndentation(self):
-        """
-        Returns the current indentation level
-        Usefull to put the caret at the good start position if we want to do autoindentation.
-
-        @return: The indentation level.
-        @rtype: int
-        """
-        return self._IP.indent_current_nsp
+                 ask_exit_handler=None):
         
-    def updateNamespace(self, ns_dict):
-        '''
-        Add the current dictionary to the shell namespace.
+        NonBlockingIPShell.__init__(self,argv,user_ns,user_global_ns,
+                                    cin, cout, cerr,
+                                    ask_exit_handler)
 
-        @param ns_dict: A dictionary of symbol-values.
-        @type ns_dict: dictionary
-        '''
-        self._IP.user_ns.update(ns_dict)
+        self.parent = parent
 
-    def complete(self, line):
-        '''
-        Returns an auto completed line and/or posibilities for completion.
+        self.ask_exit_callback = ask_exit_handler
+        self._IP.exit = self._askExit
 
-        @param line: Given line so far.
-        @type line: string
+    def addGUIShortcut(self,text,func):
+        wx.CallAfter(self.parent.add_button_handler, 
+                button_info={   'text':text, 
+                                'func':self.parent.doExecuteLine(func)})
 
-        @return: Line completed as for as possible,
-        and possible further completions.
-        @rtype: tuple
-        '''
-        split_line = self._complete_sep.split(line)
-        possibilities = self._IP.complete(split_line[-1])
-        if possibilities:
-
-            def _commonPrefix(str1, str2):
-                '''
-                Reduction function. returns common prefix of two given strings.
-
-                @param str1: First string.
-                @type str1: string
-                @param str2: Second string
-                @type str2: string
-
-                @return: Common prefix to both strings.
-                @rtype: string
-                '''
-                for i in range(len(str1)):
-                    if not str2.startswith(str1[:i+1]):
-                        return str1[:i]
-                return str1
-            common_prefix = reduce(_commonPrefix, possibilities)
-            completed = line[:-len(split_line[-1])]+common_prefix
-        else:
-            completed = line
-        return completed, possibilities
+    def _askExit(self):
+        wx.CallAfter(self.ask_exit_callback, ())
 
-    def historyBack(self):
-        '''
-        Provides one history command back.
+    def _afterExecute(self):
+        wx.CallAfter(self.parent.evtStateExecuteDone, ())
 
-        @return: The command string.
-        @rtype: string
-        '''
-        history = ''
-        #the below while loop is used to suppress empty history lines
-	while((history == '' or history == '\n') and self._history_level >0):
-		if self._history_level>=1:
-			self._history_level -= 1
-		history = self._getHistory()		
-        return history
-
-    def historyForward(self):
-        '''
-        Provides one history command forward.
-
-        @return: The command string.
-        @rtype: string
-        '''
-	history = ''
-	#the below while loop is used to suppress empty history lines
-	while((history == '' or history == '\n') and self._history_level <= self._getHistoryMaxIndex()):
-		if self._history_level < self._getHistoryMaxIndex():
-			self._history_level += 1
-			history = self._getHistory()
-		else:
-			if self._history_level == self._getHistoryMaxIndex():
-				history = self._getHistory()
-				self._history_level += 1
-			else:
-				history = ''
-        return history
-
-    def initHistoryIndex(self):
-        '''
-        set history to last command entered
-        '''
-        self._history_level = self._getHistoryMaxIndex()+1
-
-    #----------------------- IPython PRIVATE management section ----------------------    
-    def _setAskExit(self):
-        '''
-        set the _ask_exit variable that can be cjhecked by GUI to see if
-        IPython request an exit handling
-        '''
-        self._ask_exit = True
-        
-    def _getHistoryMaxIndex(self):
-        '''
-        returns the max length of the history buffer
-
-        @return: history length
-        @rtype: int
-        '''
-        return len(self._IP.input_hist_raw)-1
-        
-    def _getHistory(self):
-        '''
-        Get's the command string of the current history level.
-
-        @return: Historic command string.
-        @rtype: string
-        '''
-        rv = self._IP.input_hist_raw[self._history_level].strip('\n')
-        return rv
-
-    def _pager(self,IP,text):
-        '''
-        This function is used as a callback replacment to IPython pager function
-
-        It puts the 'text' value inside the self._doc_text string that can be retrived via getDocText
-        function.
-        '''
-        self._doc_text = text
-    
-    def _raw_input(self, prompt=''):
-        '''
-        Custom raw_input() replacement. Get's current line from console buffer.
-
-        @param prompt: Prompt to print. Here for compatability as replacement.
-        @type prompt: string
-
-        @return: The current command line text.
-        @rtype: string
-        '''
-        return self._line_to_execute
-
-    def _execute(self):
-        '''
-        Executes the current line provided by the shell object.
-        '''
-        orig_stdout = sys.stdout
-        sys.stdout = IPython.Shell.Term.cout
                 
-        try:
-            line = self._IP.raw_input(None, self._iter_more)
-            if self._IP.autoindent:
-                self._IP.readline_startup_hook(None)
-
-        except KeyboardInterrupt:
-            self._IP.write('\nKeyboardInterrupt\n')
-            self._IP.resetbuffer()
-            # keep cache in sync with the prompt counter:
-            self._IP.outputcache.prompt_count -= 1
-
-            if self._IP.autoindent:
-                self._IP.indent_current_nsp = 0
-            self._iter_more = 0
-        except:
-            self._IP.showtraceback()
-        else:
-            self._iter_more = self._IP.push(line)
-            if (self._IP.SyntaxTB.last_syntax_error and
-                    self._IP.rc.autoedit_syntax):
-                self._IP.edit_syntax_error()
-        if self._iter_more:
-            self._prompt = str(self._IP.outputcache.prompt2).strip()
-            if self._IP.autoindent:
-                self._IP.readline_startup_hook(self._IP.pre_readline)
-        else:
-            self._prompt = str(self._IP.outputcache.prompt1).strip()
-            self._IP.indent_current_nsp = 0 #we set indentation to 0
-        sys.stdout = orig_stdout
-    
-    def _shell(self, ip, cmd):
-        '''
-        Replacement method to allow shell commands without them blocking.
-
-        @param ip: Ipython instance, same as self._IP
-        @type cmd: Ipython instance
-        @param cmd: Shell command to execute.
-        @type cmd: string
-        '''
-        stdin, stdout = os.popen4(cmd)
-        result = stdout.read().decode('cp437').encode(locale.getpreferredencoding())
-        #we use print command because the shell command is called inside IPython instance and thus is
-        #redirected to thread cout
-        #"\x01\x1b[1;36m\x02" <-- add colour to the text...
-        print "\x01\x1b[1;36m\x02"+result
-        stdout.close()
-        stdin.close()
-
 class WxConsoleView(stc.StyledTextCtrl):
     '''
     Specialized styled text control view for console-like workflow.
-    We use here a scintilla frontend thus it can be reused in any GUI taht supports
-    scintilla with less work.
+    We use here a scintilla frontend thus it can be reused in any GUI that 
+    supports scintilla with less work.
 
-    @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.(with Black background)
+    @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.
+                    (with Black background)
     @type ANSI_COLORS_BLACK: dictionary
 
-    @cvar ANSI_COLORS_WHITE: Mapping of terminal colors to X11 names.(with White background)
+    @cvar ANSI_COLORS_WHITE: Mapping of terminal colors to X11 names.
+                    (with White background)
     @type ANSI_COLORS_WHITE: dictionary
 
     @ivar color_pat: Regex of terminal color pattern
     @type color_pat: _sre.SRE_Pattern
     '''
-    ANSI_STYLES_BLACK ={'0;30': [0,'WHITE'],             '0;31': [1,'RED'],
-                        '0;32': [2,'GREEN'],             '0;33': [3,'BROWN'],
-                        '0;34': [4,'BLUE'],              '0;35': [5,'PURPLE'],
-                        '0;36': [6,'CYAN'],              '0;37': [7,'LIGHT GREY'],
-                        '1;30': [8,'DARK GREY'],         '1;31': [9,'RED'],
-                        '1;32': [10,'SEA GREEN'],        '1;33': [11,'YELLOW'],
-                        '1;34': [12,'LIGHT BLUE'],       '1;35': [13,'MEDIUM VIOLET RED'],
-                        '1;36': [14,'LIGHT STEEL BLUE'], '1;37': [15,'YELLOW']}
-
-    ANSI_STYLES_WHITE ={'0;30': [0,'BLACK'],             '0;31': [1,'RED'],
-                        '0;32': [2,'GREEN'],             '0;33': [3,'BROWN'],
-                        '0;34': [4,'BLUE'],              '0;35': [5,'PURPLE'],
-                        '0;36': [6,'CYAN'],              '0;37': [7,'LIGHT GREY'],
-                        '1;30': [8,'DARK GREY'],         '1;31': [9,'RED'],
-                        '1;32': [10,'SEA GREEN'],        '1;33': [11,'YELLOW'],
-                        '1;34': [12,'LIGHT BLUE'],       '1;35': [13,'MEDIUM VIOLET RED'],
-                        '1;36': [14,'LIGHT STEEL BLUE'], '1;37': [15,'YELLOW']}
-
-    def __init__(self,parent,prompt,intro="",background_color="BLACK",pos=wx.DefaultPosition, ID = -1, size=wx.DefaultSize,
-                 style=0):
+    ANSI_STYLES_BLACK={'0;30': [0,'WHITE'],            '0;31': [1,'RED'],
+                       '0;32': [2,'GREEN'],            '0;33': [3,'BROWN'],
+                       '0;34': [4,'BLUE'],             '0;35': [5,'PURPLE'],
+                       '0;36': [6,'CYAN'],             '0;37': [7,'LIGHT GREY'],
+                       '1;30': [8,'DARK GREY'],        '1;31': [9,'RED'],
+                       '1;32': [10,'SEA GREEN'],       '1;33': [11,'YELLOW'],
+                       '1;34': [12,'LIGHT BLUE'],      '1;35': 
+                                                    [13,'MEDIUM VIOLET RED'],
+                       '1;36': [14,'LIGHT STEEL BLUE'],'1;37': [15,'YELLOW']}
+
+    ANSI_STYLES_WHITE={'0;30': [0,'BLACK'],            '0;31': [1,'RED'],
+                       '0;32': [2,'GREEN'],            '0;33': [3,'BROWN'],
+                       '0;34': [4,'BLUE'],             '0;35': [5,'PURPLE'],
+                       '0;36': [6,'CYAN'],             '0;37': [7,'LIGHT GREY'],
+                       '1;30': [8,'DARK GREY'],        '1;31': [9,'RED'],
+                       '1;32': [10,'SEA GREEN'],       '1;33': [11,'YELLOW'],
+                       '1;34': [12,'LIGHT BLUE'],      '1;35':
+                                                    [13,'MEDIUM VIOLET RED'],
+                       '1;36': [14,'LIGHT STEEL BLUE'],'1;37': [15,'YELLOW']}
+
+    def __init__(self,parent,prompt,intro="",background_color="BLACK",
+                 pos=wx.DefaultPosition, ID = -1, size=wx.DefaultSize,
+                 style=0, autocomplete_mode = 'IPYTHON'):
         '''
         Initialize console view.
 
@@ -464,15 +119,61 b' class WxConsoleView(stc.StyledTextCtrl):'
         @param background_color: Can be BLACK or WHITE
         @type background_color: string
         @param other: init param of styledTextControl (can be used as-is)
+        @param autocomplete_mode: Can be 'IPYTHON' or 'STC'
+            'IPYTHON' show autocompletion the ipython way
+            'STC" show it scintilla text control way
         '''
         stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
 
-        ####### Scintilla configuration ##################################################
+        ####### Scintilla configuration ###################################
         
-        # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside the widget
+        # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside 
+        # the widget
         self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
         self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
 
+        #We draw a line at position 80
+        self.SetEdgeMode(stc.STC_EDGE_LINE)
+        self.SetEdgeColumn(80)
+        self.SetEdgeColour(wx.LIGHT_GREY)
+
+        #self.SetViewWhiteSpace(True)
+        #self.SetViewEOL(True)
+        self.SetEOLMode(stc.STC_EOL_CRLF)
+        #self.SetWrapMode(stc.STC_WRAP_CHAR)
+        #self.SetWrapMode(stc.STC_WRAP_WORD)
+        self.SetBufferedDraw(True)
+        #self.SetUseAntiAliasing(True)
+        self.SetLayoutCache(stc.STC_CACHE_PAGE)
+        self.SetUndoCollection(False)
+	self.SetUseTabs(True)
+	self.SetIndent(4)
+	self.SetTabWidth(4)
+
+        self.EnsureCaretVisible()
+        
+        self.SetMargins(3,3) #text is moved away from border with 3px
+        # Suppressing Scintilla margins
+        self.SetMarginWidth(0,0)
+        self.SetMarginWidth(1,0)
+        self.SetMarginWidth(2,0)
+
+        self.background_color = background_color
+        self.buildStyles()
+        
+        self.indent = 0
+        self.prompt_count = 0
+        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
+        
+        self.write(intro)
+        self.setPrompt(prompt)
+        self.showPrompt()
+
+        self.autocomplete_mode = autocomplete_mode
+        
+        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress)
+        
+    def buildStyles(self):
         #we define platform specific fonts
         if wx.Platform == '__WXMSW__':
                 faces = { 'times': 'Times New Roman',
@@ -499,61 +200,64 b' class WxConsoleView(stc.StyledTextCtrl):'
                       'size2': 8,
                      }
 
-        #We draw a line at position 80
-        self.SetEdgeMode(stc.STC_EDGE_LINE)
-        self.SetEdgeColumn(80)
-        self.SetEdgeColour(wx.LIGHT_GREY)
-
-        #self.SetViewWhiteSpace(True)
-        #self.SetViewEOL(True)
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        #self.SetWrapMode(stc.STC_WRAP_CHAR)
-        #self.SetWrapMode(stc.STC_WRAP_WORD)
-        self.SetBufferedDraw(True)
-        #self.SetUseAntiAliasing(True)
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-
-        self.EnsureCaretVisible()
-        
-        self.SetMargins(3,3) #text is moved away from border with 3px
-        # Suppressing Scintilla margins
-        self.SetMarginWidth(0,0)
-        self.SetMarginWidth(1,0)
-        self.SetMarginWidth(2,0)
-
         # make some styles
-        if background_color != "BLACK":
+        if self.background_color != "BLACK":
             self.background_color = "WHITE"
             self.SetCaretForeground("BLACK")
             self.ANSI_STYLES = self.ANSI_STYLES_WHITE
         else:
-            self.background_color = background_color
             self.SetCaretForeground("WHITE")
             self.ANSI_STYLES = self.ANSI_STYLES_BLACK
 
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT, "fore:%s,back:%s,size:%d,face:%s" % (self.ANSI_STYLES['0;30'][1],
-                                                                                      self.background_color,
-                                                                                      faces['size'], faces['mono']))
+        self.StyleSetSpec(stc.STC_STYLE_DEFAULT, 
+                          "fore:%s,back:%s,size:%d,face:%s" 
+                                    % (self.ANSI_STYLES['0;30'][1],
+                          self.background_color,
+                          faces['size'], faces['mono']))
         self.StyleClearAll()
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FF0000,back:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
-    
+        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  
+                          "fore:#FF0000,back:#0000FF,bold")
+        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
+                          "fore:#000000,back:#FF0000,bold")
+
         for style in self.ANSI_STYLES.values():
             self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
         
         #######################################################################
         
-        self.indent = 0
-        self.prompt_count = 0
-        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
+    def setBackgroundColor(self,color):
+        self.background_color = color
+        self.buildStyles()
+
+    def getBackgroundColor(self,color):
+        return self.background_color
         
-        self.write(intro)
-        self.setPrompt(prompt)
-        self.showPrompt()
+    def asyncWrite(self, text):
+        '''
+        Write given text to buffer in an asynchroneous way.
+        It is used from another thread to be able to acces the GUI.
+        @param text: Text to append
+        @type text: string
+        '''
+        try:
+                #print >>sys.__stdout__,'entering'
+                wx.MutexGuiEnter()
+                #print >>sys.__stdout__,'locking the GUI'
+                
+                #be sure not to be interrutpted before the MutexGuiLeave!
+                self.write(text)
+                
+                #print >>sys.__stdout__,'done'
+                
+        except KeyboardInterrupt:
+                #print >>sys.__stdout__,'got keyboard interrupt'
+                wx.MutexGuiLeave()
+                #print >>sys.__stdout__,'interrupt unlock the GUI'
+                raise KeyboardInterrupt
+        wx.MutexGuiLeave()
+        #print >>sys.__stdout__,'normal unlock the GUI'
         
-        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress, self)
-        #self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
-
+                
     def write(self, text):
         '''
         Write given text to buffer.
@@ -641,18 +345,6 b' class WxConsoleView(stc.StyledTextCtrl):'
         return self.GetTextRange(self.getCurrentPromptStart(),
                                  self.getCurrentLineEnd())
 
-    def showReturned(self, text):
-        '''
-        Show returned text from last command and print new prompt.
-
-        @param text: Text to show.
-        @type text: string
-        '''
-        self.write('\n'+text)
-        if text:
-            self.write('\n')
-        self.showPrompt()
-
     def moveCursorOnNewValidKey(self):
         #If cursor is at wrong position put it at last line...
         if self.GetCurrentPos() < self.getCurrentPromptStart():
@@ -679,33 +371,53 b' class WxConsoleView(stc.StyledTextCtrl):'
     def writeHistory(self,history):
         self.removeFromTo(self.getCurrentPromptStart(),self.getCurrentLineEnd())
         self.changeLine(history)
+
+    def setCompletionMethod(self, completion):
+        if completion in ['IPYTHON','STC']:
+            self.autocomplete_mode = completion
+        else:
+            raise AttributeError
+
+    def getCompletionMethod(self, completion):
+        return self.autocomplete_mode
         
     def writeCompletion(self, possibilities):
-        max_len = len(max(possibilities,key=len))
-        max_symbol =' '*max_len
-        
-        #now we check how much symbol we can put on a line...
-        cursor_pos = self.getCursorPos()
-        test_buffer = max_symbol + ' '*4
-        current_lines = self.GetLineCount()
-        
-        allowed_symbols = 80/len(test_buffer)
-        if allowed_symbols == 0:
-                allowed_symbols = 1
+        if self.autocomplete_mode == 'IPYTHON':
+            max_len = len(max(possibilities,key=len))
+            max_symbol =' '*max_len
+            
+            #now we check how much symbol we can put on a line...
+            cursor_pos = self.getCursorPos()
+            test_buffer = max_symbol + ' '*4
+            current_lines = self.GetLineCount()
+            
+            allowed_symbols = 80/len(test_buffer)
+            if allowed_symbols == 0:
+                    allowed_symbols = 1
+            
+            pos = 1
+            buf = ''
+            for symbol in possibilities:
+                #buf += symbol+'\n'#*spaces)
+                if pos<allowed_symbols:
+                    spaces = max_len - len(symbol) + 4
+                    buf += symbol+' '*spaces
+                    pos += 1
+                else:
+                    buf+=symbol+'\n'
+                    pos = 1
+            self.write(buf)
+        else:
+            possibilities.sort()  # Python sorts are case sensitive
+            self.AutoCompSetIgnoreCase(False)
+            self.AutoCompSetAutoHide(False)
+            #let compute the length ot last word
+            splitter = [' ','(','[','{']
+            last_word = self.getCurrentLine()
+            for breaker in splitter:
+                last_word = last_word.split(breaker)[-1]
+            self.AutoCompShow(len(last_word), " ".join(possibilities))
         
-        pos = 1
-        buf = ''
-        for symbol in possibilities:
-            #buf += symbol+'\n'#*spaces)
-            if pos<allowed_symbols:
-                spaces = max_len - len(symbol) + 4
-                buf += symbol+' '*spaces
-                pos += 1
-            else:
-                buf+=symbol+'\n'
-                pos = 1
-        self.write(buf)
-                             
     def _onKeypress(self, event, skip=True):
         '''
         Key press callback used for correcting behavior for console-like
@@ -720,42 +432,45 b' class WxConsoleView(stc.StyledTextCtrl):'
         @return: Return True if event as been catched.
         @rtype: boolean
         '''
-	
-        if event.GetKeyCode() == wx.WXK_HOME:
-            if event.Modifiers == wx.MOD_NONE:
-                self.moveCursorOnNewValidKey()
-                self.moveCursor(self.getCurrentPromptStart())
-                return True
-            elif event.Modifiers == wx.MOD_SHIFT:
-                self.moveCursorOnNewValidKey()
-                self.selectFromTo(self.getCurrentPromptStart(),self.getCursorPos())
-                return True
-            else:
-                return False
 
-        elif event.GetKeyCode() == wx.WXK_LEFT:
-            if event.Modifiers == wx.MOD_NONE:
-                self.moveCursorOnNewValidKey()
-                
-                self.moveCursor(self.getCursorPos()-1)
-                if self.getCursorPos() < self.getCurrentPromptStart():
+        if not self.AutoCompActive():
+            if event.GetKeyCode() == wx.WXK_HOME:
+                if event.Modifiers == wx.MOD_NONE:
+                    self.moveCursorOnNewValidKey()
                     self.moveCursor(self.getCurrentPromptStart())
-                return True
-
-        elif event.GetKeyCode() == wx.WXK_BACK:
-            self.moveCursorOnNewValidKey()
-	    if self.getCursorPos() > self.getCurrentPromptStart():
-                self.removeFromTo(self.getCursorPos()-1,self.getCursorPos())
-	    return True
-        
-        if skip:
-            if event.GetKeyCode() not in [wx.WXK_PAGEUP,wx.WXK_PAGEDOWN] and event.Modifiers == wx.MOD_NONE:
+                    return True
+                elif event.Modifiers == wx.MOD_SHIFT:
+                    self.moveCursorOnNewValidKey()
+                    self.selectFromTo(self.getCurrentPromptStart(),self.getCursorPos())
+                    return True
+                else:
+                    return False
+
+            elif event.GetKeyCode() == wx.WXK_LEFT:
+                if event.Modifiers == wx.MOD_NONE:
+                    self.moveCursorOnNewValidKey()
+                    
+                    self.moveCursor(self.getCursorPos()-1)
+                    if self.getCursorPos() < self.getCurrentPromptStart():
+                        self.moveCursor(self.getCurrentPromptStart())
+                    return True
+
+            elif event.GetKeyCode() == wx.WXK_BACK:
                 self.moveCursorOnNewValidKey()
-                
+                if self.getCursorPos() > self.getCurrentPromptStart():
+                    event.Skip()
+                return True
+            
+            if skip:
+                if event.GetKeyCode() not in [wx.WXK_PAGEUP,wx.WXK_PAGEDOWN] and event.Modifiers == wx.MOD_NONE:
+                    self.moveCursorOnNewValidKey()
+                    
+                event.Skip()
+                return True
+            return False
+        else:
             event.Skip()
-            return True
-        return False
-
+            
     def OnUpdateUI(self, evt):
         # check for matching braces
         braceAtCaret = -1
@@ -791,49 +506,90 b' class WxConsoleView(stc.StyledTextCtrl):'
             #print pt
             #self.Refresh(False)
         
-class WxIPythonViewPanel(wx.Panel):
+class IPShellWidget(wx.Panel):
     '''
     This is wx.Panel that embbed the IPython Thread and the wx.StyledTextControl
-    If you want to port this to any other GUI toolkit, just replace the WxConsoleView
-    by YOURGUIConsoleView and make YOURGUIIPythonView derivate from whatever container you want.
-    I've choosed to derivate from a wx.Panel because it seems to be ore usefull
-    Any idea to make it more 'genric' welcomed.
+    If you want to port this to any other GUI toolkit, just replace the 
+    WxConsoleView by YOURGUIConsoleView and make YOURGUIIPythonView derivate 
+    from whatever container you want. I've choosed to derivate from a wx.Panel 
+    because it seems to be more useful
+    Any idea to make it more 'generic' welcomed.
     '''
-    def __init__(self,parent,exit_handler=None,intro=None,background_color="BLACK"):
+
+    def __init__(self, parent, intro=None,
+                 background_color="BLACK", add_button_handler=None, 
+                 wx_ip_shell=None, user_ns={},user_global_ns=None,
+                 ):
         '''
         Initialize.
         Instanciate an IPython thread.
         Instanciate a WxConsoleView.
         Redirect I/O to console.
         '''
-        wx.Panel.__init__(self,parent,-1)
+        wx.Panel.__init__(self,parent,wx.ID_ANY)
 
-        ### IPython thread instanciation ###
+        self.parent = parent
+        ### IPython non blocking shell instanciation ###
         self.cout = StringIO()
-        self.IP = IterableIPShell(cout=self.cout,cerr=self.cout,
-                             exit_handler = exit_handler,
-                             time_loop = 0.1)
-        self.IP.start()
-        
+        self.add_button_handler = add_button_handler
+
+        if wx_ip_shell is not None:
+            self.IP = wx_ip_shell
+        else:
+            self.IP = WxNonBlockingIPShell(self,
+                                    cout = self.cout, cerr = self.cout,
+                                    ask_exit_handler = self.askExitCallback)
+
         ### IPython wx console view instanciation ###
         #If user didn't defined an intro text, we create one for him
-        #If you really wnat an empty intrp just call wxIPythonViewPanel with intro=''
-        if intro == None:
+        #If you really wnat an empty intro just call wxIPythonViewPanel 
+        #with intro=''
+        if intro is None:
             welcome_text = "Welcome to WxIPython Shell.\n\n"
             welcome_text+= self.IP.getBanner()
             welcome_text+= "!command  -> Execute command in shell\n"
             welcome_text+= "TAB       -> Autocompletion\n"
+        else:
+            welcome_text = intro
 
         self.text_ctrl = WxConsoleView(self,
                                        self.IP.getPrompt(),
                                        intro=welcome_text,
                                        background_color=background_color)
-        
-        self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress, self.text_ctrl)
 
+        self.cout.write = self.text_ctrl.asyncWrite
+
+        option_text = wx.StaticText(self, -1, "Options:")
+        self.completion_option = wx.CheckBox(self, -1, "Scintilla Completion")
+        #self.completion_option.SetValue(False)
+        self.background_option = wx.CheckBox(self, -1, "White Background")
+        #self.background_option.SetValue(False)
+        
+        self.options={'completion':{'value':'IPYTHON',
+                                    'checkbox':self.completion_option,'STC':True,'IPYTHON':False,
+                                    'setfunc':self.text_ctrl.setCompletionMethod},
+                      'background_color':{'value':'BLACK',
+                                          'checkbox':self.background_option,'WHITE':True,'BLACK':False,
+                                          'setfunc':self.text_ctrl.setBackgroundColor},
+                     }
+        self.reloadOptions(self.options)
+        
+        self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress)
+        self.completion_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionCompletion)
+        self.background_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionBackgroundColor)
+            
         ### making the layout of the panel ###
         sizer = wx.BoxSizer(wx.VERTICAL)
         sizer.Add(self.text_ctrl, 1, wx.EXPAND)
+        option_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        sizer.Add(option_sizer, 0)
+        option_sizer.AddMany([(10, 20),
+                              (option_text, 0, wx.ALIGN_CENTER_VERTICAL),
+                              (5, 5),
+                              (self.completion_option, 0, wx.ALIGN_CENTER_VERTICAL),
+                              (8, 8),
+                              (self.background_option, 0, wx.ALIGN_CENTER_VERTICAL)
+                              ])
         self.SetAutoLayout(True)
         sizer.Fit(self)
         sizer.SetSizeHints(self)
@@ -841,158 +597,151 b' class WxIPythonViewPanel(wx.Panel):'
         #and we focus on the widget :)
         self.SetFocus()
 
-        ### below are the thread communication variable ###
-        # the IPython thread is managed via unidirectional communication.
-        # It's a thread slave that can't interact by itself with the GUI.
-        # When the GUI event loop is done runStateMachine() is called and the thread sate is then
-        # managed.
-        
-        #Initialize the state machine #kept for information
-        #self.states = ['IDLE',
-        #               'DO_EXECUTE_LINE',
-        #               'WAIT_END_OF_EXECUTION',
-        #               'SHOW_DOC',
-        #               'SHOW_PROMPT']
-        
-        self.cur_state = 'IDLE'
-	self.pager_state = 'DONE'
-        #wx.CallAfter(self.runStateMachine)
+        #widget state management (for key handling different cases)
+        self.setCurrentState('IDLE')
+        self.pager_state = 'DONE'
+        self.raw_input_current_line = 0
+
+    def askExitCallback(self, event):
+        self.askExitHandler(event)
+        
+    #---------------------- IPython Thread Management ------------------------
+    def stateDoExecuteLine(self):
+        lines=self.text_ctrl.getCurrentLine()
+        self.text_ctrl.write('\n')
+        lines_to_execute = lines.replace('\t',' '*4)
+        lines_to_execute = lines_to_execute.replace('\r','')
+        self.IP.doExecute(lines_to_execute.encode('cp1252'))
+        self.updateHistoryTracker(lines)
+        self.setCurrentState('WAIT_END_OF_EXECUTION')
+        
+    def evtStateExecuteDone(self,evt):
+        self.doc = self.IP.getDocText()
+        self.help = self.IP.getHelpText()
+        if self.doc:
+            self.pager_lines = self.doc[7:].split('\n')
+            self.pager_state = 'INIT'
+            self.setCurrentState('SHOW_DOC')
+            self.pager(self.doc)
+        elif self.help:
+            self.pager_lines = self.help.split('\n')
+            self.pager_state = 'INIT'
+            self.setCurrentState('SHOW_DOC')
+            self.pager(self.help)                
+        else:
+            self.stateShowPrompt()
+
+    def stateShowPrompt(self):
+        self.setCurrentState('SHOW_PROMPT')
+        self.text_ctrl.setPrompt(self.IP.getPrompt())
+        self.text_ctrl.setIndentation(self.IP.getIndentation())
+        self.text_ctrl.setPromptCount(self.IP.getPromptCount())
+        self.text_ctrl.showPrompt()
+        self.IP.initHistoryIndex()
+        self.setCurrentState('IDLE')
+
+    def setCurrentState(self, state):
+        self.cur_state = state
+        self.updateStatusTracker(self.cur_state)
 
-        # This creates a new Event class and a EVT binder function
-        (self.AskExitEvent, EVT_ASK_EXIT) = wx.lib.newevent.NewEvent()
+    def pager(self,text):
 
-        self.Bind(wx.EVT_IDLE, self.runStateMachine)
-        self.Bind(EVT_ASK_EXIT, exit_handler)
-        
-    def __del__(self):
-        self.IP.shutdown()
-        self.IP.join()
-        WxConsoleView.__del__()
-        
-    #---------------------------- IPython Thread Management ---------------------------------------
-    def runStateMachine(self,event):
-        #print >>self.sys_stdout,"state:",self.cur_state
-        self.updateStatusTracker(self.cur_state)
-        
-        if self.cur_state == 'DO_EXECUTE_LINE':
-            #print >>self.sys_stdout,"command:",self.getCurrentLine()
-            self.IP.doExecute(self.text_ctrl.getCurrentLine().replace('\t',' '*4))
-            self.updateHistoryTracker(self.text_ctrl.getCurrentLine())
-            self.cur_state = 'WAIT_END_OF_EXECUTION'
-        
-        if self.cur_state == 'WAIT_END_OF_EXECUTION':
-            if self.IP.isExecuteDone():
-                self.doc = self.IP.getDocText()
-                if self.IP.getAskExit():
-                    evt = self.AskExitEvent()
-                    wx.PostEvent(self, evt)
-                    self.IP.clearAskExit()
-                if self.doc:
-                    self.pager_state = 'INIT'
-		    self.cur_state = 'SHOW_DOC'
+        if self.pager_state == 'INIT':
+                #print >>sys.__stdout__,"PAGER state:",self.pager_state
+                self.pager_nb_lines = len(self.pager_lines)
+                self.pager_index = 0
+                self.pager_do_remove = False
+                self.text_ctrl.write('\n')
+                self.pager_state = 'PROCESS_LINES'
+
+        if self.pager_state == 'PROCESS_LINES':
+                #print >>sys.__stdout__,"PAGER state:",self.pager_state
+                if self.pager_do_remove == True:
+                        self.text_ctrl.removeCurrentLine()
+                        self.pager_do_remove = False
+
+                if self.pager_nb_lines > 10:
+                        #print >>sys.__stdout__,"PAGER processing 10 lines"
+                        if self.pager_index > 0:
+                                self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
+                        else:
+                                self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
+                        
+                        for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
+                                self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
+                        self.pager_index += 10
+                        self.pager_nb_lines -= 10
+                        self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
+                        self.pager_do_remove = True
+                        self.pager_state = 'WAITING'
+                        return
                 else:
-                    self.cur_state = 'SHOW_PROMPT'
-                
-        if self.cur_state == 'SHOW_PROMPT':
-            self.text_ctrl.setPrompt(self.IP.getPrompt())
-            self.text_ctrl.setIndentation(self.IP.getIndentation())
-            self.text_ctrl.setPromptCount(self.IP.getPromptCount())
-            rv = self.cout.getvalue()
-            if rv: rv = rv.strip('\n')
-            self.text_ctrl.showReturned(rv)
-            self.cout.truncate(0)
-	    self.IP.initHistoryIndex()
-            self.cur_state = 'IDLE'
-            
-        if self.cur_state == 'SHOW_DOC':
-            self.pager(self.doc)
-            if self.pager_state == 'DONE':
-                self.cur_state = 'SHOW_PROMPT'
-                
-        event.Skip()
-
-    #---------------------------- IPython pager ---------------------------------------
-    def pager(self,text):#,start=0,screen_lines=0,pager_cmd = None):
-        if self.pager_state == 'WAITING':
-		#print >>self.sys_stdout,"PAGER waiting"
-        	return
-	
-	if self.pager_state == 'INIT':
-		#print >>self.sys_stdout,"PAGER state:",self.pager_state
-        	self.pager_lines = text[7:].split('\n')
-		self.pager_nb_lines = len(self.pager_lines)
-		self.pager_index = 0
-		self.pager_do_remove = False
-		self.text_ctrl.write('\n')
-		self.pager_state = 'PROCESS_LINES'
-		
-	if self.pager_state == 'PROCESS_LINES':
-        	#print >>self.sys_stdout,"PAGER state:",self.pager_state
-        	if self.pager_do_remove == True:
-			self.text_ctrl.removeCurrentLine()
-			self.pager_do_remove = False
-	
-		if self.pager_nb_lines > 10:
-	                #print >>self.sys_stdout,"PAGER processing 10 lines"
-			if self.pager_index > 0:
-				self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-			else:
-				self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-			
-			for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
-				self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-			self.pager_index += 10
-			self.pager_nb_lines -= 10
-			self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
-			self.pager_do_remove = True
-			self.pager_state = 'WAITING'
-			return
-        	else:
-	                #print >>self.sys_stdout,"PAGER processing last lines"
-			if self.pager_nb_lines > 0:
-				if self.pager_index > 0:
-					self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-				else:
-					self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-				
-				self.pager_index += 1
+                        #print >>sys.__stdout__,"PAGER processing last lines"
+                        if self.pager_nb_lines > 0:
+                                if self.pager_index > 0:
+                                        self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
+                                else:
+                                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
+                                
+                                self.pager_index += 1
                                 self.pager_nb_lines -= 1
-	              	if self.pager_nb_lines > 0:
-        	        	for line in self.pager_lines[self.pager_index:]:
-					self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-                			self.pager_nb_lines = 0
-			self.pager_state = 'DONE'          
+                        if self.pager_nb_lines > 0:
+                                for line in self.pager_lines[self.pager_index:]:
+                                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
+                                        self.pager_nb_lines = 0
+                        self.pager_state = 'DONE'
+                        self.stateShowPrompt()
                 
-    #---------------------------- Key Handler --------------------------------------------
+    #------------------------ Key Handler ------------------------------------
     def keyPress(self, event):
         '''
         Key press callback with plenty of shell goodness, like history,
         autocompletions, etc.
         '''
-	
         if event.GetKeyCode() == ord('C'):
-            if event.Modifiers == wx.MOD_CONTROL:
+            if event.Modifiers == wx.MOD_CONTROL or event.Modifiers == wx.MOD_ALT:
                 if self.cur_state == 'WAIT_END_OF_EXECUTION':
                     #we raise an exception inside the IPython thread container
-                    self.IP.raise_exc(KeyboardInterrupt)
+                    self.IP.ce.raise_exc(KeyboardInterrupt)
                     return
                 
+        #let this before 'wx.WXK_RETURN' because we have to put 'IDLE'
+        #mode if AutoComp has been set as inactive
+        if self.cur_state == 'COMPLETING':
+            if not self.text_ctrl.AutoCompActive():
+                self.cur_state = 'IDLE'
+            else:
+                event.Skip()
+
         if event.KeyCode == wx.WXK_RETURN:
             if self.cur_state == 'IDLE':
                 #we change the state ot the state machine
-                self.cur_state = 'DO_EXECUTE_LINE'
+                self.setCurrentState('DO_EXECUTE_LINE')
+                self.stateDoExecuteLine()
                 return
+
             if self.pager_state == 'WAITING':
                 self.pager_state = 'PROCESS_LINES'
+                self.pager(self.doc)
                 return
             
+            if self.cur_state == 'WAITING_USER_INPUT':
+                line=self.text_ctrl.getCurrentLine()
+                self.text_ctrl.write('\n')
+                self.setCurrentState('WAIT_END_OF_EXECUTION')
+                return
+          
         if event.GetKeyCode() in [ord('q'),ord('Q')]:
             if self.pager_state == 'WAITING':
                 self.pager_state = 'DONE'
+                self.text_ctrl.write('\n')
+                self.stateShowPrompt()
                 return
+
+        if self.cur_state == 'WAITING_USER_INPUT':
+            event.Skip()   
             
-        #scroll_position = self.text_ctrl.GetScrollPos(wx.VERTICAL)
-	if self.cur_state == 'IDLE':
+        if self.cur_state == 'IDLE':
             if event.KeyCode == wx.WXK_UP:
                 history = self.IP.historyBack()
                 self.text_ctrl.writeHistory(history)
@@ -1008,19 +757,68 b' class WxIPythonViewPanel(wx.Panel):'
                     return
                 completed, possibilities = self.IP.complete(self.text_ctrl.getCurrentLine())
                 if len(possibilities) > 1:
-                    cur_slice = self.text_ctrl.getCurrentLine()
-                    self.text_ctrl.write('\n')
-                    self.text_ctrl.writeCompletion(possibilities)
-                    self.text_ctrl.write('\n')
-
-                    self.text_ctrl.showPrompt()
-                    self.text_ctrl.write(cur_slice)
-                self.text_ctrl.changeLine(completed or cur_slice)
-                
+                    if self.text_ctrl.autocomplete_mode == 'IPYTHON':    
+                        cur_slice = self.text_ctrl.getCurrentLine()
+                        self.text_ctrl.write('\n')
+                        self.text_ctrl.writeCompletion(possibilities)
+                        self.text_ctrl.write('\n')
+
+                        self.text_ctrl.showPrompt()
+                        self.text_ctrl.write(cur_slice)
+                        self.text_ctrl.changeLine(completed or cur_slice)
+                    else:
+                        self.cur_state = 'COMPLETING'
+                        self.text_ctrl.writeCompletion(possibilities)
+                else:
+                    self.text_ctrl.changeLine(completed or cur_slice)
                 return
             event.Skip()
-	
-    #---------------------------- Hook Section --------------------------------------------
+
+    #------------------------ Option Section ---------------------------------
+    def evtCheckOptionCompletion(self, event):
+        if event.IsChecked():
+            self.options['completion']['value']='STC'
+        else:
+            self.options['completion']['value']='IPYTHON'
+        self.text_ctrl.setCompletionMethod(self.options['completion']['value'])
+        self.updateOptionTracker('completion',
+                                 self.options['completion']['value'])
+        self.text_ctrl.SetFocus()
+
+    def evtCheckOptionBackgroundColor(self, event):
+        if event.IsChecked():
+            self.options['background_color']['value']='WHITE'
+        else:
+            self.options['background_color']['value']='BLACK'
+        self.text_ctrl.setBackgroundColor(self.options['background_color']['value'])
+        self.updateOptionTracker('background_color',
+                                 self.options['background_color']['value'])
+        self.text_ctrl.SetFocus()
+    
+    def getOptions(self):
+        return self.options
+        
+    def reloadOptions(self,options):
+        self.options = options
+        for key in self.options.keys():
+            value = self.options[key]['value']
+            self.options[key]['checkbox'].SetValue(self.options[key][value])
+            self.options[key]['setfunc'](value)
+        
+        
+    #------------------------ Hook Section -----------------------------------
+    def updateOptionTracker(self,name,value):
+        '''
+        Default history tracker (does nothing)
+        '''
+        pass
+    
+    def setOptionTrackerHook(self,func):
+        '''
+        Define a new history tracker
+        '''
+        self.updateOptionTracker = func
+
     def updateHistoryTracker(self,command_line):
         '''
         Default history tracker (does nothing)
@@ -1032,6 +830,7 b' class WxIPythonViewPanel(wx.Panel):'
         Define a new history tracker
         '''
         self.updateHistoryTracker = func
+
     def updateStatusTracker(self,status):
         '''
         Default status tracker (does nothing)
@@ -1043,4 +842,36 b' class WxIPythonViewPanel(wx.Panel):'
         Define a new status tracker
         '''
         self.updateStatusTracker = func
-    
+
+    def askExitHandler(self, event):
+        '''
+        Default exit handler
+        '''
+        self.text_ctrl.write('\nExit callback has not been set.')
+
+    def setAskExitHandler(self, func):
+        '''
+        Define an exit handler
+        '''
+        self.askExitHandler = func
+
+if __name__ == '__main__':
+    # Some simple code to test the shell widget.
+    class MainWindow(wx.Frame):
+        def __init__(self, parent, id, title):
+            wx.Frame.__init__(self, parent, id, title, size=(300,250))
+            self._sizer = wx.BoxSizer(wx.VERTICAL)
+            self.shell = IPShellWidget(self)
+            self._sizer.Add(self.shell, 1, wx.EXPAND)
+            self.SetSizer(self._sizer)
+            self.SetAutoLayout(1)
+            self.Show(True)
+
+    app = wx.PySimpleApp()
+    frame = MainWindow(None, wx.ID_ANY, 'Ipython')
+    frame.SetSize((780, 460))
+    shell = frame.shell
+
+    app.MainLoop()
+
+

IPython/gui/wx/thread_ex.py

@@ -1,45 +1,50 b''
-import threading
-import inspect
-import ctypes
- 
- 
-def _async_raise(tid, exctype):
-    """raises the exception, performs cleanup if needed"""
-    if not inspect.isclass(exctype):
-        raise TypeError("Only types can be raised (not instances)")
-    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
-    if res == 0:
-        raise ValueError("invalid thread id")
-    elif res != 1:
-        # """if it returns a number greater than one, you're in trouble, 
-        # and you should call it again with exc=NULL to revert the effect"""
-        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
-        raise SystemError("PyThreadState_SetAsyncExc failed")
- 
- 
-class Thread(threading.Thread):
-    def _get_my_tid(self):
-        """determines this (self's) thread id"""
-        if not self.isAlive():
-            raise threading.ThreadError("the thread is not active")
-        
-        # do we have it cached?
-        if hasattr(self, "_thread_id"):
-            return self._thread_id
-        
-        # no, look for it in the _active dict
-        for tid, tobj in threading._active.items():
-            if tobj is self:
-                self._thread_id = tid
-                return tid
-        
-        raise AssertionError("could not determine the thread's id")
-    
-    def raise_exc(self, exctype):
-        """raises the given exception type in the context of this thread"""
-        _async_raise(self._get_my_tid(), exctype)
-    
-    def kill(self):
-        """raises SystemExit in the context of the given thread, which should 
-        cause the thread to exit silently (unless caught)"""
-        self.raise_exc(SystemExit)
+"""
+Thread subclass that can deal with asynchronously function calls via
+raise_exc.
+"""
+
+import threading
+import inspect
+import ctypes
+ 
+ 
+def _async_raise(tid, exctype):
+    """raises the exception, performs cleanup if needed"""
+    if not inspect.isclass(exctype):
+        raise TypeError("Only types can be raised (not instances)")
+    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
+    if res == 0:
+        raise ValueError("invalid thread id")
+    elif res != 1:
+        # """if it returns a number greater than one, you're in trouble, 
+        # and you should call it again with exc=NULL to revert the effect"""
+        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
+        raise SystemError("PyThreadState_SetAsyncExc failed")
+ 
+ 
+class ThreadEx(threading.Thread):
+    def _get_my_tid(self):
+        """determines this (self's) thread id"""
+        if not self.isAlive():
+            raise threading.ThreadError("the thread is not active")
+        
+        # do we have it cached?
+        if hasattr(self, "_thread_id"):
+            return self._thread_id
+        
+        # no, look for it in the _active dict
+        for tid, tobj in threading._active.items():
+            if tobj is self:
+                self._thread_id = tid
+                return tid
+        
+        raise AssertionError("could not determine the thread's id")
+    
+    def raise_exc(self, exctype):
+        """raises the given exception type in the context of this thread"""
+        _async_raise(self._get_my_tid(), exctype)
+    
+    def kill(self):
+        """raises SystemExit in the context of the given thread, which should 
+        cause the thread to exit silently (unless caught)"""
+        self.raise_exc(SystemExit)

IPython/gui/wx/wxIPython.py

@@ -2,11 +2,13 b''
 # -*- coding: iso-8859-15 -*-
 
 import wx.aui
-import wx.py
+
+#used for about dialog
 from wx.lib.wordwrap import wordwrap
 
-from ipython_view import *
-from ipython_history import *
+#used for ipython GUI objects
+from IPython.gui.wx.ipython_view import IPShellWidget
+from IPython.gui.wx.ipython_history import IPythonHistoryPanel
 
 __version__ = 0.8
 __author__  = "Laurent Dufrechou"
@@ -20,7 +22,8 b' __license__ = "BSD"'
 class MyFrame(wx.Frame):
     """Creating one main frame for our 
     application with movables windows"""
-    def __init__(self, parent=None, id=-1, title="WxIPython", pos=wx.DefaultPosition,
+    def __init__(self, parent=None, id=-1, title="WxIPython", 
+                pos=wx.DefaultPosition,
                 size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
         wx.Frame.__init__(self, parent, id, title, pos, size, style)
         self._mgr = wx.aui.AuiManager()
@@ -30,15 +33,18 b' class MyFrame(wx.Frame):'
         
         #create differents panels and make them persistant 
         self.history_panel    = IPythonHistoryPanel(self)
+
+        self.history_panel.setOptionTrackerHook(self.optionSave)
         
-        self.ipython_panel    = WxIPythonViewPanel(self,self.OnExitDlg,
-                                                   background_color = "BLACK")
-        
-        #self.ipython_panel    = WxIPythonViewPanel(self,self.OnExitDlg,
-        #                                           background_color = "WHITE")
-        
+        self.ipython_panel    = IPShellWidget(self,background_color = "BLACK")
+        #self.ipython_panel    = IPShellWidget(self,background_color = "WHITE")
+
         self.ipython_panel.setHistoryTrackerHook(self.history_panel.write)
         self.ipython_panel.setStatusTrackerHook(self.updateStatus)
+        self.ipython_panel.setAskExitHandler(self.OnExitDlg)
+        self.ipython_panel.setOptionTrackerHook(self.optionSave)
+
+        self.optionLoad()
         
         self.statusbar = self.createStatus()
         self.createMenu()
@@ -48,13 +54,11 b' class MyFrame(wx.Frame):'
         # main panels
         self._mgr.AddPane(self.ipython_panel , wx.CENTER, "IPython Shell")
         self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
-        
+                
         # now we specify some panel characteristics
         self._mgr.GetPane(self.ipython_panel).CaptionVisible(True);
         self._mgr.GetPane(self.history_panel).CaptionVisible(True);
         self._mgr.GetPane(self.history_panel).MinSize((200,400));
-                
-        
         
         # tell the manager to "commit" all the changes just made
         self._mgr.Update()
@@ -66,7 +70,7 b' class MyFrame(wx.Frame):'
         self.Bind(wx.EVT_MENU,  self.OnShowHistoryPanel,id=wx.ID_HIGHEST+2)
         self.Bind(wx.EVT_MENU,  self.OnShowAbout, id=wx.ID_HIGHEST+3)
         self.Bind(wx.EVT_MENU,  self.OnShowAllPanel,id=wx.ID_HIGHEST+6)
-
+        
         warn_text = 'Hello from IPython and wxPython.\n'
         warn_text +='Please Note that this work is still EXPERIMENTAL\n'
         warn_text +='It does NOT emulate currently all the IPython functions.\n'
@@ -78,7 +82,41 b' class MyFrame(wx.Frame):'
                                )
         dlg.ShowModal()
         dlg.Destroy()
-     
+
+    def optionSave(self, name, value):
+        opt = open('options.conf','w')
+
+        try:
+            options_ipython_panel = self.ipython_panel.getOptions()
+            options_history_panel = self.history_panel.getOptions()
+
+            for key in options_ipython_panel.keys():
+                opt.write(key + '=' + options_ipython_panel[key]['value']+'\n')
+            for key in options_history_panel.keys():
+                opt.write(key + '=' + options_history_panel[key]['value']+'\n')
+        finally:    
+            opt.close()
+        
+    def optionLoad(self):
+        opt = open('options.conf','r')
+        lines = opt.readlines()
+        opt.close()
+                      
+        options_ipython_panel = self.ipython_panel.getOptions()
+        options_history_panel = self.history_panel.getOptions()
+        
+        for line in lines:
+            key = line.split('=')[0]
+            value = line.split('=')[1].replace('\n','').replace('\r','')
+            if key in options_ipython_panel.keys():
+                options_ipython_panel[key]['value'] = value
+            elif key in options_history_panel.keys():
+                options_history_panel[key]['value'] = value
+            else:
+                print >>sys.__stdout__,"Warning: key ",key,"not found in widget options. Check Options.conf"
+        self.ipython_panel.reloadOptions(options_ipython_panel)
+        self.history_panel.reloadOptions(options_history_panel)
+        
     def createMenu(self):
         """local method used to create one menu bar"""
         
@@ -121,6 +159,7 b' class MyFrame(wx.Frame):'
         states = {'IDLE':'Idle',
                   'DO_EXECUTE_LINE':'Send command',
                   'WAIT_END_OF_EXECUTION':'Running command',
+                  'WAITING_USER_INPUT':'Waiting user input',
                   'SHOW_DOC':'Showing doc',
                   'SHOW_PROMPT':'Showing prompt'}
         self.statusbar.SetStatusText(states[text], 0)

IPython/hooks.py

@@ -56,7 +56,7 b' from pprint import PrettyPrinter'
 __all__ = ['editor', 'fix_error_editor', 'result_display',
            'input_prefilter', 'shutdown_hook', 'late_startup_hook',
            'generate_prompt', 'generate_output_prompt','shell_hook',
-           'show_in_pager']
+           'show_in_pager','pre_prompt_hook', 'pre_runcode_hook']
 
 pformat = PrettyPrinter().pformat
 
@@ -227,11 +227,17 b' def show_in_pager(self,s):'
     # raising TryNext here will use the default paging functionality
     raise ipapi.TryNext
 
-def pre_command_hook(self,cmd):
-    """" Executed before starting to execute a command """
+def pre_prompt_hook(self):
+    """ Run before displaying the next prompt
+    
+    Use this e.g. to display output from asynchronous operations (in order 
+    to not mess up text entry)   
+    """
+    
     return None
 
-def post_command_hook(self,cmd):
-    """ Executed after executing a command """
+def pre_runcode_hook(self):
+    """ Executed before running the (prefiltered) code in IPython """
+    return None
     
 

IPython/ipapi.py

@@ -273,15 +273,27 b' class IPApi:'
             """
             res = []
             lines = script.splitlines()
+
             level = 0
             for l in lines:
-                stripped = l.lstrip()
-                if not l.strip():
+                lstripped = l.lstrip()
+                stripped = l.strip()                
+                if not stripped:
                     continue
-                newlevel = len(l) - len(stripped)
-                if level > 0 and newlevel == 0:
+                newlevel = len(l) - len(lstripped)
+                def is_secondary_block_start(s):
+                    if not s.endswith(':'):
+                        return False
+                    if (s.startswith('elif') or 
+                        s.startswith('else') or 
+                        s.startswith('except') or
+                        s.startswith('finally')):
+                        return True
+                        
+                if level > 0 and newlevel == 0 and not is_secondary_block_start(stripped): 
                     # add empty line
                     res.append('')
+                    
                 res.append(l)
                 level = newlevel
             return '\n'.join(res) + '\n'
@@ -291,7 +303,7 b' class IPApi:'
         else:
             script = '\n'.join(lines)
         clean=cleanup_ipy_script(script)
-
+        # print "_ip.runlines() script:\n",clean #dbg
         self.IP.runlines(clean)
     def to_user_ns(self,vars, interactive = True):
         """Inject a group of variables into the IPython user namespace.
@@ -533,7 +545,7 b' class DebugTools:'
         if name in self.hotnames:
             self.debug_stack( "HotName '%s' caught" % name)
 
-def launch_new_instance(user_ns = None):
+def launch_new_instance(user_ns = None,shellclass = None):
     """ Make and start a new ipython instance.
     
     This can be called even without having an already initialized 
@@ -542,7 +554,7 b' def launch_new_instance(user_ns = None):'
     This is also used as the egg entry point for the 'ipython' script.
     
     """
-    ses = make_session(user_ns)
+    ses = make_session(user_ns,shellclass)
     ses.mainloop()
 
 
@@ -578,7 +590,7 b' def make_user_global_ns(ns = None):'
     return ns
 
 
-def make_session(user_ns = None):
+def make_session(user_ns = None, shellclass = None):
     """Makes, but does not launch an IPython session.
     
     Later on you can call obj.mainloop() on the returned object.
@@ -591,6 +603,6 b' def make_session(user_ns = None):'
     WARNING: This should *not* be run when a session exists already."""
 
     import IPython.Shell
-    return IPython.Shell.start(user_ns)
-
-
+    if shellclass is None:
+        return IPython.Shell.start(user_ns)
+    return shellclass(user_ns = user_ns)

IPython/iplib.py

@@ -6,7 +6,6 b' Requires Python 2.3 or newer.'
 
 This file contains all the classes and helper functions specific to IPython.
 
-$Id: iplib.py 3005 2008-02-01 16:43:34Z vivainio $
 """
 
 #*****************************************************************************
@@ -55,6 +54,8 b' import sys'
 import tempfile
 import traceback
 import types
+import warnings
+warnings.filterwarnings('ignore', r'.*sets module*')
 from sets import Set
 from pprint import pprint, pformat
 
@@ -377,7 +378,10 b' class InteractiveShell(object,Magic):'
         # Get system encoding at startup time.  Certain terminals (like Emacs
         # under Win32 have it set to None, and we need to have a known valid
         # encoding to use in the raw_input() method
-        self.stdin_encoding = sys.stdin.encoding or 'ascii'
+        try:
+            self.stdin_encoding = sys.stdin.encoding or 'ascii'
+        except AttributeError:
+            self.stdin_encoding = 'ascii'
 
         # dict of things NOT to alias (keywords, builtins and some magics)
         no_alias = {}
@@ -698,7 +702,10 b' class InteractiveShell(object,Magic):'
 
         # Do a proper resetting of doctest, including the necessary displayhook
         # monkeypatching
-        doctest_reload()
+        try:
+            doctest_reload()
+        except ImportError:
+            warn("doctest module does not exist.")
         
         # Set user colors (don't do it in the constructor above so that it
         # doesn't crash if colors option is invalid)
@@ -1266,8 +1273,12 b' want to merge them back into the new files.""" % locals()'
         """Reload the input history from disk file."""
 
         if self.has_readline:
-            self.readline.clear_history()
-            self.readline.read_history_file(self.shell.histfile)
+            try:
+                self.readline.clear_history()
+                self.readline.read_history_file(self.shell.histfile)
+            except AttributeError:
+                pass
+            
 
     def history_saving_wrapper(self, func):
         """ Wrap func for readline history saving
@@ -1744,6 +1755,7 b' want to merge them back into the new files.""" % locals()'
         # exit_now is set by a call to %Exit or %Quit
         
         while not self.exit_now:
+            self.hooks.pre_prompt_hook()
             if more:
                 try:
                     prompt = self.hooks.generate_prompt(True)
@@ -2009,7 +2021,7 b' want to merge them back into the new files.""" % locals()'
 
         try:
             code = self.compile(source,filename,symbol)
-        except (OverflowError, SyntaxError, ValueError):
+        except (OverflowError, SyntaxError, ValueError, TypeError):
             # Case 1
             self.showsyntaxerror(filename)
             return None
@@ -2053,6 +2065,7 b' want to merge them back into the new files.""" % locals()'
         outflag = 1  # happens in more places, so it's easier as default
         try:
             try:
+                self.hooks.pre_runcode_hook()
                 # Embedded instances require separate global/local namespaces
                 # so they can see both the surrounding (local) namespace and
                 # the module-level globals when called inside another function.

IPython/ipmaker.py

@@ -58,6 +58,14 b' from IPython.iplib import InteractiveShell'
 from IPython.usage import cmd_line_usage,interactive_usage
 from IPython.genutils import *
 
+def force_import(modname):
+    if modname in sys.modules:
+        print "reload",modname
+        reload(sys.modules[modname])
+    else:
+        __import__(modname)
+        
+
 #-----------------------------------------------------------------------------
 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
                  rc_override=None,shell_class=InteractiveShell,
@@ -95,9 +103,12 b' def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,'
                      embedded=embedded,**kw)
 
     # Put 'help' in the user namespace
-    from site import _Helper
+    try:
+        from site import _Helper
+        IP.user_ns['help'] = _Helper()
+    except ImportError:
+        warn('help() not available - check site.py')
     IP.user_config_ns = {}
-    IP.user_ns['help'] = _Helper()
 
 
     if DEVDEBUG:
@@ -176,10 +187,10 b" object? -> Details about 'object'. ?object also works, ?? prints more."
 
     # 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 interact|i ipythondir=s Version upgrade '
-                    'gthread! qthread! q4thread! wthread! tkthread! pylab! tk!')
+                    'gthread! qthread! q4thread! wthread! tkthread! pylab! tk! '
+                    # 'twisted!'  # disabled for now.
+                    )
 
     # Build the actual name list to be used by DPyGetOpt
     opts_names = qw(cmdline_opts) + qw(cmdline_only)
@@ -203,7 +214,7 b" object? -> Details about 'object'. ?object also works, ?? prints more."
                       editor = '0',
                       gthread = 0,
                       help = 0,
-                      interact = 1,
+                      interact = 0,
                       ipythondir = ipythondir_def,
                       log = 0,
                       logfile = '',
@@ -237,6 +248,7 b" object? -> Details about 'object'. ?object also works, ?? prints more."
                       system_verbose = 0,
                       term_title = 1,
                       tk = 0,
+                      #twisted= 0,  # disabled for now
                       upgrade = 0,
                       Version = 0,
                       wildcards_case_sensitive = 1,
@@ -633,15 +645,17 b" object? -> Details about 'object'. ?object also works, ?? prints more."
     if opts_all.profile and not profile_handled_by_legacy:
         profmodname = 'ipy_profile_' + opts_all.profile
         try:
-            __import__(profmodname)
+            
+            force_import(profmodname)
         except:
             IP.InteractiveTB()
             print "Error importing",profmodname,"- perhaps you should run %upgrade?"
             import_fail_info(profmodname)
     else:
-        import ipy_profile_none
-    try:    
-        import ipy_user_conf
+        force_import('ipy_profile_none')
+    try:
+            
+        force_import('ipy_user_conf')
         
     except:
         conf = opts_all.ipythondir + "/ipy_user_conf.py"

IPython/platutils_posix.py

@@ -23,12 +23,17 b' __license__ = Release.license'
 import sys
 import os
 
+ignore_termtitle = False
 
 def _dummy_op(*a, **b):
     """ A no-op function """
 
 def _set_term_title_xterm(title):
     """ Change virtual terminal title in xterm-workalikes """
+
+    if ignore_termtitle:
+        return
+    
     sys.stdout.write('\033]%d;%s\007' % (0,title))
 
 
@@ -37,4 +42,6 b" if os.environ.get('TERM','') == 'xterm':"
 else:
     set_term_title = _dummy_op
 
-    
+def freeze_term_title():
+    global ignore_termtitle
+    ignore_termtitle = True

IPython/platutils_win32.py

@@ -50,4 +50,7 b' def set_term_title(title):'
         return
     _set_term_title(title)
 
+def freeze_term_title():
+    global ignore_termtitle
+    ignore_termtitle = 1
 

IPython/ultraTB.py

@@ -377,8 +377,8 b' class ListTB(TBTools):'
         
     def __call__(self, etype, value, elist):
         Term.cout.flush()
-        Term.cerr.flush()
         print >> Term.cerr, self.text(etype,value,elist)
+        Term.cerr.flush()
 
     def text(self,etype, value, elist,context=5):
         """Return a color formatted string with the traceback info."""
@@ -855,8 +855,8 b' class VerboseTB(TBTools):'
         (etype, evalue, etb) = info or sys.exc_info()
         self.tb = etb
         Term.cout.flush()
-        Term.cerr.flush()
         print >> Term.cerr, self.text(etype, evalue, etb)
+        Term.cerr.flush()
 
     # Changed so an instance can just be called as VerboseTB_inst() and print
     # out the right info on its own.
@@ -977,13 +977,13 b' class AutoFormattedTB(FormattedTB):'
         if out is None:
             out = Term.cerr
         Term.cout.flush()
-        out.flush()
         if tb_offset is not None:
             tb_offset, self.tb_offset = self.tb_offset, tb_offset
             print >> out, self.text(etype, evalue, etb)
             self.tb_offset = tb_offset
         else:
             print >> out, self.text(etype, evalue, etb)
+        out.flush()
         try:
             self.debugger()
         except KeyboardInterrupt:

MANIFEST.in

@@ -9,22 +9,23 b' graft setupext'
 graft IPython/UserConfig
 
 graft doc
+exclude doc/\#*
 exclude doc/*.1
-exclude doc/manual_base*
 exclude doc/ChangeLog.*
-exclude doc/\#*
-exclude doc/update_magic.sh
 exclude doc/update_version.sh
-exclude doc/manual_base*
-exclude doc/manual/WARNINGS
-exclude doc/manual/*.aux
-exclude doc/manual/*.log
-exclude doc/manual/*.out
-exclude doc/manual/*.pl
-exclude doc/manual/*.tex
+
+# There seems to be no way of excluding whole subdirectories, other than
+# manually excluding all their subdirs.  distutils really is horrible...
+exclude doc/attic/*
+exclude doc/build/doctrees/*
+exclude doc/build/html/_sources/*
+exclude doc/build/html/_static/*
+exclude doc/build/html/*
+exclude doc/build/latex/*
 
 global-exclude *~
 global-exclude *.flc
 global-exclude *.pyc
 global-exclude .dircopy.log
 global-exclude .svn
+global-exclude .bzr

debian/changelog

@@ -1,8 +1,330 b''
+ipython (0.8.1-2) unstable; urgency=low
+
+  [ Piotr Ożarowski ]
+  * Homepage field added
+  * Rename XS-Vcs-* fields to Vcs-* (dpkg supports them now)
+  * Add 04_remove_shebang patch
+  * Removing lintian overrides, adding proper patches instead.
+
+  [ Bernd Zeimetz ]
+  * Replacing Recommends by Suggests to stop ipython from installing ~500MB
+    of dependencies. Thanks to Marcela Tiznado (Closes: #451887).
+
+ -- Bernd Zeimetz <[e-mail]>  Mon, 19 Nov 2007 19:10:14 +0100
+
+ipython (0.8.1-1) unstable; urgency=low
+
+  [ Bernd Zeimetz ]
+  * debian/control:
+     - adding python-matplotlib to Recommends because
+       it is needed to run ipython -pylab
+
+  [ Norbert Tretkowski ]
+  * New upstream release. (closes: #428398)
+
+  [ Reinhard Tartler ]
+  * Install ipython.el properly.
+
+ -- Norbert Tretkowski <[e-mail]>  Mon, 11 Jun 2007 20:05:30 +0200
+
+ipython (0.8.0-2) unstable; urgency=low
+
+  * debian/changelog:
+     - adding missing colons to Closes entries to fix two
+       lintian warnings
+  * debian/compat:
+     - bumping compat level to 5
+  * debian/control:
+     - adding XS-Vcs-Browser
+     - remove no longer needed X*-Python-Version fields
+     - moving python-pexpect from Recommends to Depends because
+       /usr/bin/irunner is not useable without it
+     - moving debhelper and dpatch from Build-Depends-Indep to
+       Build-Depends, fixing the following lintian errors:
+         - clean-should-be-satisfied-by-build-depends debhelper
+         - clean-should-be-satisfied-by-build-depends dpatch
+     - removing unnecessary Build-Depends-Indep on python-all-dev,
+       adding python to Build-Depends instead
+     - replacing python-central by python-support to be able to
+       fix #420134 without hassle
+     - adding ${misc:Depends}
+     - adding the missing identation for Homepage:
+     - adding cdbs as Build-Depends
+     - adding myself to Uploaders
+     - removing the short description from the long description
+  * debian/patches/03_ipy_gnuglobal.dpatch:
+     - fix the location of the global binary - we're not on windows
+  * debian/rules:
+     - removing old crust, using cdbs to make things clear again
+     - using python-support instead of python-central to make
+       modules for 2.5 avaiable now. (Closes: #420134)
+     - making sure the bogus /usr/IPython directory is not
+       included in the package again
+     - do not remove docs/ipython.el (Closes: #198505, #415427)
+  * adding lintian ovverrides for several scripts included in the
+    IPython/Extensions directory.
+  * adding a manpage for /usr/bin/irunner
+
+ -- Bernd Zeimetz <[e-mail]>  Tue, 24 Apr 2007 02:47:26 +0200
+
+ipython (0.8.0-1) unstable; urgency=low
+
+  * New upstream release. (closes: #419716)
+  * Removed patches merged upstream.
+
+ -- Norbert Tretkowski <[e-mail]>  Tue, 17 Apr 2007 20:26:43 +0200
+
+ipython (0.7.3-2) unstable; urgency=low
+
+  * Added a new patch from svn to fix jobctrl to work properly on posix.
+
+ -- Norbert Tretkowski <[e-mail]>  Thu, 21 Dec 2006 20:13:57 +0100
+
+ipython (0.7.3-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Norbert Tretkowski <[e-mail]>  Mon, 18 Dec 2006 22:23:55 +0100
+
+ipython (0.7.3~rc2-1) experimental; urgency=low
+
+  * New upstream release candidate.
+
+ -- Norbert Tretkowski <[e-mail]>  Sat, 16 Dec 2006 02:20:13 +0100
+
+ipython (0.7.3~beta2-1) experimental; urgency=low
+
+  * New upstream beta release.
+
+ -- Norbert Tretkowski <[e-mail]>  Fri,  8 Dec 2006 08:02:16 +0100
+
+ipython (0.7.3~beta1-1) experimental; urgency=low
+
+  * New upstream beta release.
+  * Removed backported patch added in 0.7.2-5 to workaround bugs in python
+    2.3's inspect module.
+
+ -- Norbert Tretkowski <[e-mail]>  Wed, 29 Nov 2006 12:35:22 +0100
+
+ipython (0.7.2-6) UNRELEASED; urgency=low
+
+  * Added XS-Vcs-Svn field.
+
+ -- Piotr Ozarowski <[e-mail]>  Thu, 23 Nov 2006 14:44:43 +0100
+
+ipython (0.7.2-5) unstable; urgency=low
+
+  * Added a new patch from svn to workaround bugs in python 2.3's inspect
+    module. (closes: #374625)
+
+ -- Norbert Tretkowski <[e-mail]>  Thu, 10 Aug 2006 18:36:12 +0200
+
+ipython (0.7.2-4) unstable; urgency=low
+
+  * Fixed spelling error in description. (closes: #363976)
+  * Ack NMU 0.7.2-3.1, thanks Matthias. (closes: #377787)
+
+ -- Norbert Tretkowski <[e-mail]>  Tue,  1 Aug 2006 22:45:11 +0200
+
+ipython (0.7.2-3.1) unstable; urgency=medium
+
+  * NMU.
+  * Convert to updated Python policy. (closes: #377787)
+
+ -- Matthias Klose <[e-mail]>  Thu, 13 Jul 2006 17:42:06 +0000
+
+ipython (0.7.2-3ubuntu1) edgy; urgency=low
+
+  * Synchronize with Debian unstable.
+  * Convert to updated Python policy. Collapse all packages into one
+    ipython package, don't handle ipython using alternatives.
+
+ -- Matthias Klose <[e-mail]>  Tue, 11 Jul 2006 09:47:37 +0000
+
+ipython (0.7.2-3) unstable; urgency=low
+
+  * Removed alternative for irunner manpage.
+
+ -- Norbert Tretkowski <[e-mail]>  Sat, 17 Jun 2006 09:49:10 +0200
+
+ipython (0.7.2-2) unstable; urgency=medium
+
+  * Fixed conflict in irunner. (closes: #373874)
+  * Added recommendation for python-pexpect. (closes: #373794)
+
+ -- Norbert Tretkowski <[e-mail]>  Fri, 16 Jun 2006 10:43:45 +0200
+
+ipython (0.7.2-1) unstable; urgency=low
+
+  [ Piotr Ozarowski ]
+  * Added watch file.
+
+  [ Norbert Tretkowski ]
+  * New upstream release.
+
+ -- Norbert Tretkowski <[e-mail]>  Thu,  8 Jun 2006 23:36:03 +0200
+
+ipython (0.7.1.fix1+0.7.2.rc1-1) experimental; urgency=low
+
+  * New upstream release candidate.
+  * Updated Standards-Version to 3.7.2.0, no changes required.
+
+ -- Norbert Tretkowski <[e-mail]>  Sat, 27 May 2006 14:49:24 +0200
+
+ipython (0.7.1.fix1-2) unstable; urgency=low
+
+  * Set maintainer to Debian Python modules team and added myself to
+    uploaders.
+
+ -- Norbert Tretkowski <[e-mail]>  Sun, 16 Apr 2006 15:53:43 +0200
+
+ipython (0.7.1.fix1-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+  * Removed backported patch which was added in 0.7.1-3 to catch
+    KeyboardInterrupt exceptions properly, it's part of this release.
+  * Fixed names of pdfs in doc-base file to shut up linda.
+
+ -- Norbert Tretkowski <[e-mail]>  Tue, 14 Feb 2006 23:51:17 +0100
+
+ipython (0.7.1-3) unstable; urgency=low
+
+  * Added a new patch from upstream to catch KeyboardInterrupt exceptions
+    properly.
+
+ -- Norbert Tretkowski <[e-mail]>  Mon, 30 Jan 2006 19:42:31 +0100
+
+ipython (0.7.1-2) unstable; urgency=low
+
+  * Really remove alternatives on purge, thanks Lars Wirzenius for finding
+    the problem. (closes: #317269)
+
+ -- Norbert Tretkowski <[e-mail]>  Sun, 29 Jan 2006 23:11:28 +0100
+
+ipython (0.7.1-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Norbert Tretkowski <[e-mail]>  Tue, 24 Jan 2006 21:42:33 +0100
+
+ipython (0.7.0-2) unstable; urgency=low
+
+  * Fixed circular dependencies (closes: #341980)
+  * Added version to dependency on ipython dummy package. (closes: #320235)
+  * Removed python2.2 package, ipython now depends on python >= 2.3.
+  * Bumped up standards-version, no changes needed.
+
+ -- Norbert Tretkowski <[e-mail]>  Sat, 21 Jan 2006 23:27:53 +0100
+
+ipython (0.7.0-1) unstable; urgency=low
+
+  * New upstream release.
+  * Updated 01_docdir-base.dpatch and 02_profiler-message.dpatch.
+
+ -- Norbert Tretkowski <[e-mail]>  Sat, 21 Jan 2006 20:08:23 +0100
+
+ipython (0.6.15-2) unstable; urgency=low
+
+  * New maintainer, thanks Jack for your work.
+
+ -- Norbert Tretkowski <[e-mail]>  Sun, 28 Aug 2005 19:57:09 +0200
+
+ipython (0.6.15-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Norbert Tretkowski <[e-mail]>  Thu,  2 Jun 2005 23:51:45 +0200
+
+ipython (0.6.14-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Norbert Tretkowski <[e-mail]>  Tue, 31 May 2005 22:53:25 +0200
+
+ipython (0.6.13-1) unstable; urgency=low
+
+  * New upstream release.
+  * Removed backported patch which was added in 0.6.12-3 to fix misleading
+    prompt, it's part of this release.
+
+ -- Norbert Tretkowski <[e-mail]>  Fri, 15 Apr 2005 09:42:35 +0200
+
+ipython (0.6.12-4) unstable; urgency=medium
+
+  * Re-added python build-dependency, it got lost in 0.6.12-2.
+    (closes: #301636)
+
+ -- Norbert Tretkowski <[e-mail]>  Sun, 27 Mar 2005 14:28:26 +0200
+
+ipython (0.6.12-3) unstable; urgency=low
+
+  * Added a new patch from cvs to fix misleading prompt2. (closes: #300847)
+
+ -- Norbert Tretkowski <[e-mail]>  Sun, 27 Mar 2005 00:05:26 +0100
+
+ipython (0.6.12-2) unstable; urgency=low
+
+  * Added packages for python2.2 and python2.4, ipython package is now a dummy
+    package depending on ipython built for Debians default python.
+    (closes: #292537)
+  * Split out generic files into separate ipython-common package.
+  * Enhanced package descriptions.
+  * Removed CFLAGS settings from debian/rules, not required.
+  * Tweaked message displayed when profiler support is missing.
+  * Suggest the python-profiler package.
+
+ -- Norbert Tretkowski <[e-mail]>  Fri, 25 Mar 2005 20:24:36 +0100
+
+ipython (0.6.12-1) unstable; urgency=low
+
+  * New upstream release.
+  * Removed patch which was added in 0.6.5-1.1 to make profiling support
+    optional, it was merged upstream.
+
+ -- Norbert Tretkowski <[e-mail]>  Wed,  2 Mar 2005 12:15:09 +0100
+
+ipython (0.6.11-1) unstable; urgency=low
+
+  * New upstream release.
+    + Fixed broken profiling support unless -D is specified. (closes: #295779)
+  * Acknowledged NMUs. (closes: #206653, #294500, #294861, #280505)
+  * New co-maintainer, added myself to uploaders.
+
+ -- Norbert Tretkowski <[e-mail]>  Tue,  1 Mar 2005 12:40:33 +0100
+
+ipython (0.6.5-1.2) unstable; urgency=low
+
+  * Non-maintainer upload.
+  * Rebuild with a python version that is actually in Debian.
+
+ -- Wichert Akkerman <[e-mail]>  Thu, 17 Feb 2005 23:08:52 +0100
+
+ipython (0.6.5-1.1) unstable; urgency=low
+
+  * NMU to apply patch making profiling support optional (provided by
+    Torsten Marek). (closes: #294500)
+
+ -- Steven R. Baker <[e-mail]>  Thu, 17 Feb 2005 05:02:55 -0400
+
+ipython (0.6.5-1) unstable; urgency=low
+
+  * New upstream release
+
+ -- Jack Moffitt <[e-mail]>  Thu,  2 Dec 2004 15:49:27 -0700
+
+ipython (0.6.4-1.1) unstable; urgency=low
+
+  * NMU from BSP Frankfurt:
+    - Added Build-Depends on dpatch (Closes: #280505)
+
+ -- Joerg Jaspert <[e-mail]>  Sat, 27 Nov 2004 18:28:17 +0100
+
 ipython (0.6.4-1) unstable; urgency=low
 
-  * Fix dpatch dependency (Closes: #280505)
+  * New upstream release
+  * Updated debian/rules to use dpatch and added debian/patches/*
 
- -- Fernando Perez <[e-mail]> Wed Nov 17 22:54:23 MST 2004
+ -- Jack Moffitt <[e-mail]>  Tue,  9 Nov 2004 10:38:51 -0700
 
 ipython (0.6.3-1) unstable; urgency=low
 
@@ -27,8 +349,8 b' ipython (0.4.0-1.1) unstable; urgency=low'
 
 ipython (0.4.0-1) unstable; urgency=low
 
-  * New upstream release (Closes #195215)
-  * Updated Build-Depends (Closes #200021)
+  * New upstream release (Closes: #195215)
+  * Updated Build-Depends (Closes: #200021)
 
  -- Jack Moffitt <[e-mail]>  Fri, 25 Jul 2003 10:16:12 -0600
 

debian/compat

@@ -1,1 +1,1 b''
-4
+5

debian/control

@@ -1,21 +1,26 b''
 Source: ipython
-Section: devel
+Section: python
 Priority: optional
-Maintainer: Jack Moffitt <[e-mail]>
-Build-Depends-Indep: debhelper (>> 4.1.65), dpatch, python-dev
-Standards-Version: 3.6.1
+Maintainer: Debian Python Modules Team <[e-mail]>
+Uploaders: Norbert Tretkowski <[e-mail]>, Bernd Zeimetz <[e-mail]>
+Build-Depends: debhelper (>= 5.0.37.2), dpatch (>= 2.0.10), cdbs (>= 0.4.43), python, python-support (>= 0.4)
+Homepage: http://ipython.scipy.org/
+Vcs-Svn: svn://svn.debian.org/python-modules/packages/ipython/trunk/
+Vcs-Browser: http://svn.debian.org/wsvn/python-modules/packages/ipython/trunk/
+Standards-Version: 3.7.2.2
 
 Package: ipython
 Architecture: all
-Depends: ${python:Depends}
-Recommends: python-numeric, python-numeric-ext
-Description: An enhanced interactive Python shell
- IPython is an enhanced interactive Python shell.  It can be used as a
- replacement for the standard Python shell, or it can be used as a
- complete working environment for scientific computing (like Matlab or
- Mathematica) when paired with the standard Python scientific and
- numerical tools.  It supports dynamic object introspections, numbered
- input/output prompts, a macro system, session logging, session
- restoring, complete system shell access, verbose and colored
- traceback reports, auto-parentheses, auto-quoting, and is
- embeddedable in other Python programs.
+Depends: ${python:Depends}, ${misc:Depends}, python-pexpect
+Conflicts: python2.3-ipython, python2.4-ipython, ipython-common
+Replaces: python2.3-ipython, python2.4-ipython, ipython-common
+Suggests: python-profiler, python-numeric, python-numeric-ext, python-matplotlib
+Description: enhanced interactive Python shell
+ IPython can be used as a replacement for the standard Python shell,
+ or it can be used as a complete working environment for scientific
+ computing (like Matlab or Mathematica) when paired with the standard
+ Python scientific and numerical tools. It supports dynamic object
+ introspections, numbered input/output prompts, a macro system,
+ session logging, session restoring, complete system shell access,
+ verbose and colored traceback reports, auto-parentheses, auto-quoting,
+ and is embeddable in other Python programs.

debian/copyright

@@ -4,51 +4,15 b' Wed, 12 Mar 2003 20:38:14 -0700.'
 It was downloaded from http://ipython.scipy.org/
 
 Upstream Author: Fernando Perez <[e-mail]>,
-		 Janko Hauser <[e-mail]>,
+		 Janko Hauser <[e-mail]>,
 		 Nathaniel Gray <[e-mail]>
 
 Copyright:
 
-Most IPython code is copyright (C) 2001-2004 by Fernando Perez, Janko Hauser,
-and Nathaniel Gray.  All code is licensed under a BSD-type License except as
-explicitly mentioned below.  The full IPython license is:
-
-IPython is released under a BSD-type license.
-
-Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez <[e-mail]>.
-
-Copyright (c) 2001 Janko Hauser <[e-mail]> and Nathaniel Gray
-<[e-mail]>.
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  a. Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-
-  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.
-
-  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.
-
-
-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.
-
+Most IPython code is copyright (C) 2001 by Fernando Perez, Janko
+Hauser, and Nathaniel Gray.  All code is licensed under the GNU Lesser
+General Public License (LGPL) except as explicitly mentioned below.
+Its full text is included in the file /usr/share/common-licenses/LGPL.
 
 DPyGetOpt.py is copyright (C) 2001 by Bill Bumgarner <[e-mail]>
 and is licensed under the MIT license, reproduced below:

debian/rules

@@ -1,98 +1,25 b''
 #!/usr/bin/make -f
-# Sample debian/rules that uses debhelper.
-# GNU copyright 1997 to 1999 by Joey Hess.
-
-# Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
-
-
-
-
-CFLAGS = -Wall -g
-
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
-	CFLAGS += -O0
-else
-	CFLAGS += -O2
-endif
-ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
-	INSTALL_PROGRAM += -s
-endif
-
-configure: configure-stamp
-configure-stamp:
-	dh_testdir
-
-	python setup.py config
-
-	touch configure-stamp
-
-
-build: build-stamp
-
-build-stamp: configure-stamp 
-	dh_testdir
-
-	python setup.py build
-
-	touch build-stamp
-
-clean:
-	dh_testdir
-	dh_testroot
-	rm -f build-stamp configure-stamp
-
-	-python setup.py clean --all
-	rm -f setupext/*.pyc
-
-	dh_clean
-
-install: build
-	dh_testdir
-	dh_testroot
-	dh_clean -k
-	dh_installdirs
-
-	python setup.py install --prefix $(CURDIR)/debian/ipython/usr
-
-	# remove extra license docs that get installed
-	rm -f $(CURDIR)/debian/ipython/usr/share/doc/ipython/COPYING
-	#rm -f $(CURDIR)/debian/ipython/usr/share/doc/ipython/GNU-LGPL
-
+# ipython debian/rules file
+DEB_PYTHON_SYSTEM=pysupport
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/python-distutils.mk
+include /usr/share/cdbs/1/rules/dpatch.mk
+
+install/ipython::
+	# remove documentation
+	rm $(CURDIR)/debian/ipython/usr/share/doc/ipython/COPYING
+	rm $(CURDIR)/debian/ipython/usr/share/doc/ipython/ChangeLog
+	rm $(CURDIR)/debian/ipython/usr/share/doc/ipython/README_Windows.txt
+	rm $(CURDIR)/debian/ipython/usr/share/doc/ipython/pycon.ico
+	
 	# change permission on scripts
-	chmod 755 $(CURDIR)/debian/ipython/usr/share/doc/ipython/examples/example-embed.py	
-	chmod 755 $(CURDIR)/debian/ipython/usr/share/doc/ipython/examples/example-gnuplot.py
-
-binary-indep: build install
-	dh_testdir
-	dh_testroot
-	dh_installchangelogs doc/ChangeLog
-	dh_installdocs
-#	dh_installexamples
-	dh_install
-#	dh_installmenu
-#	dh_installdebconf	
-#	dh_installlogrotate
-#	dh_installemacsen
-#	dh_installpam
-#	dh_installmime
-#	dh_installinit
-#	dh_installcron
-#	dh_installinfo
-	dh_installman doc/ipython.1.gz doc/pycolor.1.gz
-	dh_compress
-	dh_fixperms
-	dh_python
-#	dh_makeshlibs
-	dh_installdeb
-#	dh_shlibdeps
-	dh_gencontrol
-	dh_md5sums
-	dh_builddeb
-
-# Build architecture-dependent files here.
-binary-arch: build install
-# We have nothing to do by default.
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure
+	chmod a-x $(CURDIR)/debian/ipython/usr/share/doc/ipython/examples/*
+	
+	# removing bogus usr/IPython directory
+	rm -rf $(CURDIR)/debian/ipython/usr/IPython
+
+binary-fixup/ipython::
+	# fix lintian warnings (see also patches/04_remove_shebang.dpatch)
+	chmod +x $(CURDIR)/debian/ipython/usr/share/python-support/ipython/IPython/upgrade_dir.py
+	chmod +x $(CURDIR)/debian/ipython/usr/share/python-support/ipython/IPython/Extensions/pickleshare.py
+	chmod +x $(CURDIR)/debian/ipython/usr/share/python-support/ipython/IPython/irunner.py

doc/ChangeLog

@@ -1,11 +1,232 b''
[phone]  *** Released version 0.8.4
+
[phone]  Fernando Perez  <[e-mail]>
+
+	* IPython/ipmaker.py (make_IPython): The -twisted option is fully
+	disabled.
+
+	* IPython/Shell.py (_select_shell): completely disable -twisted.
+	This code is of dubious quality and  normal users should not
+	encounter it until we can clarify things further, even under
+	win32.  Since we need a quick emergency 0.8.4 release, it is now
+	disabled completely.  Users who want to run it can use the
+	following command (it's easy to put it in an alias or script):
+	
+	python -c"from IPython import twshell;twshell.IPShellTwisted().mainloop()"
+
[phone]  Ville Vainio <[e-mail]>
+
+	* shell.py: disable -twisted on non-win32 platforms.
+	import sets module on python 2.3.
+
+	* ipy_profile_sh.py: disable ipy_signals. Now, ipython
+	is verified to work with python 2.3
+	
+	* Release.py: update version to 0.8.4 for quick point fix
+
[phone]  *** Released version 0.8.3
+
[phone]  Fernando Perez  <[e-mail]>
+
+	* ../win32_manual_post_install.py (run): Fix the windows installer
+	so the links to the docs are correct.
+
+	* IPython/ultraTB.py: flush stderr after writing to it to fix
+	problems with exception traceback ordering in some platforms.
+	Thanks to a report/fix by Jie Tang <jietang86-AT-gmail.com>.
+
+	* IPython/Magic.py (magic_cpaste): add stripping of continuation
+	prompts, feature requested by Stefan vdW.
+
+	* ../setup.py: updates to build and release tools in preparation
+	for 0.8.3 release.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* iplib.py, ipmaker.py: survive lack of doctest and site._Helper
+	for minimal environments (e.g. Maemo sdk python)
+
+	* Magic.py: cpaste strips whitespace before >>> (allow pasting
+	doctests)
+
+	* ipy_completers.py: cd completer now does recursive path expand
+	(old behaviour is buggy on some readline versions)
+
[phone]  Ville Vainio <[e-mail]>
+
+	* Extensions/ipy_greedycompleter.py: 
+	New extension that enables a bit more "relaxed" tab 
+	completer that evaluates code without safety checks
+	(i.e. there can be side effects like function calls)
+
[phone]  Ville Vainio <[e-mail]>
+
+	* Extensions/ipy_lookfor.py: add %lookfor magic command
+	(search docstrings for words) by Pauli Virtanen. Close #245.
+
+	* Extension/ipy_jot.py: %jot and %read magics, analogous
+	to %store but you can specify some notes. Not read 
+	in automatically on startup, you need %read.
+	Contributed by Yichun Wei.
+
[phone]  Fernando Perez  <[e-mail]>
+
+	* IPython/genutils.py (page): apply workaround to curses bug that
+	can leave terminal corrupted after a call to initscr().
+
[phone]  Ville Vainio <[e-mail]>
+
+	* genutils.py: SList.grep supports 'field' argument
+
+	* ipy_completers.py: module completer looks inside
+	.egg zip files (patch by mc). Close #196.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* deep_reload.py: do not crash on from __future__ import 
+	absolute_import. Close #244.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipy_winpdb.py: New extension for winpdb integration.  %wdb
+	test.py is winpdb equivalent of %run -d test.py.  winpdb is a
+	crossplatform remote GUI debugger based on wxpython.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipython.rst, do_sphinx.py: New documentation base, based on
+	reStucturedText and Sphinx (html/pdf generation).  The old Lyx
+	based documentation will not be updated anymore.
+
+	* jobctrl.py: Use shell in Popen for 'start' command (in windows).
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipython.rst, do_sphinx.py: New documentation base, based on
+	reStucturedText and Sphinx (html/pdf generation).  The old Lyx
+	based documentation will not be updated anymore.
+
+	ipython.rst has up to date documentation on matters that were not
+	documented at all, and it also removes various
+	misdocumented/deprecated features.
+	
[phone]  Ville Vainio <[e-mail]>
+
+	* Shell.py: Merge mtexp branch:
+	https://code.launchpad.net/~ipython/ipython/mtexp
+
+	Privides simpler and more robust MTInteractiveShell that won't
+	deadlock, even when the worker thread (GUI) stops doing runcode()
+	regularly. r71.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* twshell.py: New shell that runs IPython code in Twisted reactor.
+	Launch by doing ipython -twisted. r67.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* Magic.py: %rehashx works correctly when shadowed system commands
+	have upper case characters (e.g. Print.exe). r64.
+
+	* ipy_bzr.py, ipy_app_completers.py: new bzr completer that also
+	knows options to commands, based on bzrtools. Uses bzrlib
+	directly. r66.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* make_tarball.py: Fixed for bzr.
+
+	* ipapi.py: Better _ip.runlines() script cleanup. r56,r79.
+
+	 * ipy_vimserver.py, ipy.vim: New extension for vim server mode,
+	 by Erich Heine.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipmaker.py: Force (reload?) import of ipy_user_conf and
+	ipy_profile_foo, so that embedded instances can be relaunched and
+	configuration is still done. r50
+
+	* ipapi.py, test_embed.py: Allow specifying shell class in
+	launch_new_instance & make_new instance. Use this in
+	test_embed.py. r51.
+
+	test_embed.py is also a good and simple demo of embedding IPython.
+	
+
[phone]  Ville Vainio <[e-mail]>
+
+	* tool/update_revnum.py: Change to bzr revisioning scheme in 
+	revision numbers.
+
+	* Shell.py: Threading improvements:
+
+	In multithreaded shells, do not hang on macros and o.autoexec
+	commands (or anything executed with _ip.runlines()) anymore. Allow
+	recursive execution of IPython code in
+	MTInteractiveShell.runsource by checking if we are already in
+	worker thread, and execute code directly if we are. r48.
+
+	MTInteractiveShell.runsource: execute code directly if worker
+	thread is not running yet (this is the case in config files). r49.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipy_profile_sh.py: You can now use $LA or LA() to refer to last
+	argument of previous command in sh profile. Similar to bash '!$'.
+	LA(3) or $LA(3) stands for last argument of input history command 
+	3.
+
+	* Shell.py: -pylab names don't clutter %whos listing.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipy_autoreload.py: new extension (by Pauli Virtanen) for 
+	autoreloading modules; try %autoreload and %aimport. Close #154.
+	Uses the new pre_runcode_hook.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* platutils_posix.py: freeze_term_title works
+
[phone]  Ville Vainio <[e-mail]>
+
+	* Magic.py: %quickref does not crash with empty docstring
+
[phone]  Ville Vainio <[e-mail]>
+
+	* completer.py: do not treat [](){} as protectable chars anymore,
+	close #233.
+
+	* completer.py: do not treat [](){} as protectable chars anymore
+	
+	* magic.py, test_cpaste.py: Allow different prefix for pasting 
+	from email
+
[phone]  Ville Vainio <[e-mail]>
+
+	* Switched over to Launchpad/bzr as primary VCS.
+
[phone]  Ville Vainio <[e-mail]>
+
+	* ipapi.py: _ip.runlines() is now much more liberal about 
+	indentation - it cleans up the scripts it gets
+	
[phone]  Ville Vainio <[e-mail]>
+
+	* Extensions/ipy_leo.py: created 'ILeo' IPython-Leo bridge.
+	Changes to it (later on) are too numerous to list in ChangeLog
+	until it stabilizes
+	
 2008-02-07  Darren Dale <[e-mail]>
 
-        * IPython/Shell.py: Call QtCore.pyqtRemoveInputHook() when creating
-        an IPShellQt4. PyQt4-4.2.1 and later uses PyOS_InputHook to improve 
-        interaction in the interpreter (like Tkinter does), but it seems to 
-        partially interfere with the IPython implementation and exec_()
-        still seems to block. So we disable the PyQt implementation and
-        stick with the IPython one for now.
+	* IPython/Shell.py: Call QtCore.pyqtRemoveInputHook() when creating
+	an IPShellQt4. PyQt4-4.2.1 and later uses PyOS_InputHook to improve 
+	interaction in the interpreter (like Tkinter does), but it seems to 
+	partially interfere with the IPython implementation and exec_()
+	still seems to block. So we disable the PyQt implementation and
+	stick with the IPython one for now.
 
 2008-02-02  Walter Doerwald  <[e-mail]>
 

doc/examples/extension.py

@@ -1,20 +1,20 b''
-# -*- coding: utf-8 -*-
-
-import IPython.ipapi
-ip = IPython.ipapi.get()
-
-def ${name}_f(self, arg):
-    r""" Short explanation
-    
-    Long explanation, examples
-    
-    """
-    
-    # opts,args = self.parse_options(arg,'rx')
-    # if 'r' in opts: pass
-    
-    
-
-ip.expose_magic("${name}",${name}_f)        
-    
-    
+# -*- coding: utf-8 -*-
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def ${name}_f(self, arg):
+    r""" Short explanation
+    
+    Long explanation, examples
+    
+    """
+    
+    # opts,args = self.parse_options(arg,'rx')
+    # if 'r' in opts: pass
+    
+    
+
+ip.expose_magic("${name}",${name}_f)        
+    
+    

doc/examples/ipython_here_shell_extension.reg

@@ -1,6 +1,6 b''
- Windows Registry Editor Version 5.00
-
-[HKEY_CLASSES_ROOT\Directory\shell\IPython here]
-
-[HKEY_CLASSES_ROOT\Directory\shell\IPython here\Command]
+ Windows Registry Editor Version 5.00
+
+[HKEY_CLASSES_ROOT\Directory\shell\IPython here]
+
+[HKEY_CLASSES_ROOT\Directory\shell\IPython here\Command]
 @="cmd.exe /C ipython.py -p sh -i -c \"%cd %1\""
  No newline at end of file

doc/ipython.1

@@ -36,11 +36,11 b' 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, \-q4thread, \-wthread, \-pylab
+.B \-gthread, \-qthread, \-q4thread, \-wthread, \-pylab, \-twisted
 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, QT3, QT4 and WXWidgets toolkits, and for the
-matplotlib library.
+threading support for the GTK, QT3, QT4 and WXWidgets toolkits, for the
+matplotlib library and Twisted reactor.
 .br
 .sp 1
 With any of the first four options, IPython starts running a separate thread
@@ -56,6 +56,10 b' request a specific version of wx to be used. This requires that you have the'
 distributions.
 .br
 .sp 1
+If \-twisted is given, IPython start a Twisted reactor and runs IPython mainloop
+in a dedicated thread, passing commands to be run inside the Twisted reactor. 
+.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