ipapi, ileo: fix _ip.runlines() cleanup routine for better handling of secondary blocks (else etc)

IPython/Extensions/ipy_leo.py

@@ -1,586 +1,585 b''
 """ 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
 
 @IPython.generics.complete_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()
         
-        script = g.splitLines(script + '\n')
         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):
     push_from_leo(LeoNode(p))         
 
 @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/ipapi.py

@@ -1,597 +1,608 b''
 ''' IPython customization API
 
 Your one-stop module for configuring & extending ipython
 
 The API will probably break when ipython 1.0 is released, but so 
 will the other configuration method (rc files).
 
 All names prefixed by underscores are for internal use, not part 
 of the public api.
 
 Below is an example that you can just put to a module and import from ipython. 
 
 A good practice is to install the config script below as e.g. 
 
 ~/.ipython/my_private_conf.py
 
 And do 
 
 import_mod my_private_conf 
 
 in ~/.ipython/ipythonrc
 
 That way the module is imported at startup and you can have all your
 personal configuration (as opposed to boilerplate ipythonrc-PROFILENAME 
 stuff) in there. 
 
 -----------------------------------------------
 import IPython.ipapi
 ip = IPython.ipapi.get()
 
 def ankka_f(self, arg):
     print "Ankka",self,"says uppercase:",arg.upper()
 
 ip.expose_magic("ankka",ankka_f)
 
 ip.magic('alias sayhi echo "Testing, hi ok"')
 ip.magic('alias helloworld echo "Hello world"')
 ip.system('pwd')
 
 ip.ex('import re')
 ip.ex("""
 def funcci(a,b):
     print a+b
 print funcci(3,4)
 """)
 ip.ex("funcci(348,9)")
 
 def jed_editor(self,filename, linenum=None):
     print "Calling my own editor, jed ... via hook!"
     import os
     if linenum is None: linenum = 0
     os.system('jed +%d %s' % (linenum, filename))
     print "exiting jed"
 
 ip.set_hook('editor',jed_editor)
 
 o = ip.options
 o.autocall = 2  # FULL autocall mode
 
 print "done!"
 '''
 
 # stdlib imports
 import __builtin__
 import sys
 
 try: # Python 2.3 compatibility
     set
 except NameError:
     import sets
     set = sets.Set
 
 # our own
 #from IPython.genutils import warn,error
  
 class TryNext(Exception):
     """Try next hook exception.
      
     Raise this in your hook function to indicate that the next hook handler
     should be used to handle the operation.  If you pass arguments to the
     constructor those arguments will be used by the next hook instead of the
     original ones.
     """
 
     def __init__(self, *args, **kwargs):
         self.args = args
         self.kwargs = kwargs
 
 class UsageError(Exception):
     """ Error in magic function arguments, etc.
     
     Something that probably won't warrant a full traceback, but should
     nevertheless interrupt a macro / batch file.   
     """
 
 class IPyAutocall:
     """ Instances of this class are always autocalled
     
     This happens regardless of 'autocall' variable state. Use this to
     develop macro-like mechanisms.
     """
     
     def set_ip(self,ip):
         """ Will be used to set _ip point to current ipython instance b/f call
         
         Override this method if you don't want this to happen.
         
         """
         self._ip = ip
     
 
 # contains the most recently instantiated IPApi
 
 class IPythonNotRunning:
     """Dummy do-nothing class.
 
     Instances of this class return a dummy attribute on all accesses, which
     can be called and warns.  This makes it easier to write scripts which use
     the ipapi.get() object for informational purposes to operate both with and
     without ipython.  Obviously code which uses the ipython object for
     computations will not work, but this allows a wider range of code to
     transparently work whether ipython is being used or not."""
 
     def __init__(self,warn=True):
         if warn:
             self.dummy = self._dummy_warn
         else:
             self.dummy = self._dummy_silent
     
     def __str__(self):
         return "<IPythonNotRunning>"
 
     __repr__ = __str__
 
     def __getattr__(self,name):
         return self.dummy
 
     def _dummy_warn(self,*args,**kw):
         """Dummy function, which doesn't do anything but warn."""
 
         print ("IPython is not running, this is a dummy no-op function")
 
     def _dummy_silent(self,*args,**kw):
         """Dummy function, which doesn't do anything and emits no warnings."""
         pass
 
 _recent = None
 
 
 def get(allow_dummy=False,dummy_warn=True):
     """Get an IPApi object.
 
     If allow_dummy is true, returns an instance of IPythonNotRunning 
     instead of None if not running under IPython.
 
     If dummy_warn is false, the dummy instance will be completely silent.
 
     Running this should be the first thing you do when writing extensions that
     can be imported as normal modules. You can then direct all the
     configuration operations against the returned object.
     """
     global _recent
     if allow_dummy and not _recent:
         _recent = IPythonNotRunning(dummy_warn)
     return _recent
 
 class IPApi:
     """ The actual API class for configuring IPython 
     
     You should do all of the IPython configuration by getting an IPApi object
     with IPython.ipapi.get() and using the attributes and methods of the
     returned object."""
     
     def __init__(self,ip):
         
         # All attributes exposed here are considered to be the public API of
         # IPython.  As needs dictate, some of these may be wrapped as
         # properties.
 
         self.magic = ip.ipmagic
         
         self.system = ip.system
         
         self.set_hook = ip.set_hook
         
         self.set_custom_exc = ip.set_custom_exc
 
         self.user_ns = ip.user_ns
         self.user_ns['_ip'] = self
 
         self.set_crash_handler = ip.set_crash_handler
 
         # Session-specific data store, which can be used to store
         # data that should persist through the ipython session.
         self.meta =  ip.meta
     
         # The ipython instance provided
         self.IP = ip
 
         self.extensions = {}
 
         self.dbg = DebugTools(self)
         
         global _recent
         _recent = self
 
     # Use a property for some things which are added to the instance very
     # late.  I don't have time right now to disentangle the initialization
     # order issues, so a property lets us delay item extraction while
     # providing a normal attribute API.
     def get_db(self):
         """A handle to persistent dict-like database (a PickleShareDB object)"""
         return self.IP.db
 
     db = property(get_db,None,None,get_db.__doc__)
 
     def get_options(self):
         """All configurable variables."""
         
         # catch typos by disabling new attribute creation. If new attr creation
         # is in fact wanted (e.g. when exposing new options), do allow_new_attr(True) 
         # for the received rc struct.
         
         self.IP.rc.allow_new_attr(False)
         return self.IP.rc
 
     options = property(get_options,None,None,get_options.__doc__)
     
     def expose_magic(self,magicname, func):
         ''' Expose own function as magic function for ipython 
     
         def foo_impl(self,parameter_s=''):
             """My very own magic!. (Use docstrings, IPython reads them)."""
             print 'Magic function. Passed parameter is between < >: <'+parameter_s+'>'
             print 'The self object is:',self
     
         ipapi.expose_magic("foo",foo_impl)
         '''
                 
         import new
         im = new.instancemethod(func,self.IP, self.IP.__class__)
         old = getattr(self.IP, "magic_" + magicname, None)
         if old:
             self.dbg.debug_stack("Magic redefinition '%s', old %s" % (magicname,
                                  old))
             
         setattr(self.IP, "magic_" + magicname, im)
     
     def ex(self,cmd):
         """ Execute a normal python statement in user namespace """
         exec cmd in self.user_ns
     
     def ev(self,expr):
         """ Evaluate python expression expr in user namespace 
         
         Returns the result of evaluation"""
         return eval(expr,self.user_ns)
     
     def runlines(self,lines):
         """ Run the specified lines in interpreter, honoring ipython directives.
         
         This allows %magic and !shell escape notations.
         
         Takes either all lines in one string or list of lines.
         """
 
         def cleanup_ipy_script(script):
             """ Make a script safe for _ip.runlines() 
             
             - Removes empty lines
             - Suffixes all indented blocks that end with unindented lines with empty lines
             
             """
             res = []
             lines = script.splitlines()
+
             level = 0
             for l in lines:
                 lstripped = l.lstrip()
                 stripped = l.strip()
                 if not stripped:
                     continue
                 newlevel = len(l) - len(lstripped)
-                if level > 0 and newlevel == 0 and not stripped.endswith(':'):
+                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'
         
         if isinstance(lines,basestring):
             script = lines            
         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.
 
         Inputs:
 
          - vars: string with variable names separated by whitespace, or a
          dict with name/value pairs.
 
          - interactive: if True (default), the var will be listed with
         %whos et. al.
          
         This utility routine is meant to ease interactive debugging work,
         where you want to easily propagate some internal variable in your code
         up to the interactive namespace for further exploration.
 
         When you run code via %run, globals in your script become visible at
         the interactive prompt, but this doesn't happen for locals inside your
         own functions and methods.  Yet when debugging, it is common to want
         to explore some internal variables further at the interactive propmt.
 
         Examples:
 
         To use this, you first must obtain a handle on the ipython object as
         indicated above, via:
 
         import IPython.ipapi
         ip = IPython.ipapi.get()
 
         Once this is done, inside a routine foo() where you want to expose
         variables x and y, you do the following:
 
         def foo():
             ...
             x = your_computation()
             y = something_else()
             
             # This pushes x and y to the interactive prompt immediately, even
             # if this routine crashes on the next line after:
             ip.to_user_ns('x y')
             ...
             
             # To expose *ALL* the local variables from the function, use:
             ip.to_user_ns(locals())
 
             ...
             # return           
         
 
         If you need to rename variables, the dict input makes it easy.  For
         example, this call exposes variables 'foo' as 'x' and 'bar' as 'y'
         in IPython user namespace:
 
         ip.to_user_ns(dict(x=foo,y=bar))    
         """
 
         # print 'vars given:',vars # dbg
         
         # We need a dict of name/value pairs to do namespace updates.
         if isinstance(vars,dict):
             # If a dict was given, no need to change anything.
             vdict = vars
         elif isinstance(vars,basestring):
             # If a string with names was given, get the caller's frame to
             # evaluate the given names in
             cf = sys._getframe(1)
             vdict = {}
             for name in vars.split():
                 try:
                     vdict[name] = eval(name,cf.f_globals,cf.f_locals)
                 except:
                     print ('could not get var. %s from %s' %
                     (name,cf.f_code.co_name))
         else:
             raise ValueError('vars must be a string or a dict')
             
         # Propagate variables to user namespace
         self.user_ns.update(vdict)
 
         # And configure interactive visibility
         config_ns = self.IP.user_config_ns
         if interactive:
             for name,val in vdict.iteritems():
                 config_ns.pop(name,None)
         else:
             for name,val in vdict.iteritems():
                 config_ns[name] = val                    
 
 
     def expand_alias(self,line):
         """ Expand an alias in the command line 
         
         Returns the provided command line, possibly with the first word 
         (command) translated according to alias expansion rules.
         
         [ipython]|16> _ip.expand_aliases("np myfile.txt")
                  <16> 'q:/opt/np/notepad++.exe myfile.txt'
         """
         
         pre,fn,rest = self.IP.split_user_input(line)
         res = pre + self.IP.expand_aliases(fn,rest)
         return res
 
     def itpl(self, s, depth = 1):
         """ Expand Itpl format string s.
         
         Only callable from command line (i.e. prefilter results);
         If you use in your scripts, you need to use a bigger depth!
         """
         return self.IP.var_expand(s, depth)
         
     def defalias(self, name, cmd):
         """ Define a new alias
         
         _ip.defalias('bb','bldmake bldfiles')
         
         Creates a new alias named 'bb' in ipython user namespace
         """
 
         self.dbg.check_hotname(name)
         
 
         if name in self.IP.alias_table:
             self.dbg.debug_stack("Alias redefinition: '%s' => '%s' (old '%s')" %
                              (name, cmd, self.IP.alias_table[name]))
             
 
         if callable(cmd):
             self.IP.alias_table[name] = cmd
             import IPython.shadowns
             setattr(IPython.shadowns, name,cmd)
             return
             
         if isinstance(cmd,basestring):
             nargs = cmd.count('%s')
             if nargs>0 and cmd.find('%l')>=0:
                 raise Exception('The %s and %l specifiers are mutually exclusive '
                                 'in alias definitions.')
                   
             self.IP.alias_table[name] = (nargs,cmd)
             return
         
         # just put it in - it's probably (0,'foo')
         self.IP.alias_table[name] = cmd
     
     def defmacro(self, *args):
         """ Define a new macro
     
         2 forms of calling:
         
         mac = _ip.defmacro('print "hello"\nprint "world"')
         
         (doesn't put the created macro on user namespace)
         
         _ip.defmacro('build', 'bldmake bldfiles\nabld build winscw udeb')
         
         (creates a macro named 'build' in user namespace)
         """
         
         import IPython.macro
         
         if len(args) == 1:
             return IPython.macro.Macro(args[0])
         elif len(args) == 2:
             self.user_ns[args[0]] = IPython.macro.Macro(args[1])
         else:
             return Exception("_ip.defmacro must be called with 1 or 2 arguments")
         
     def set_next_input(self, s):
         """ Sets the 'default' input string for the next command line.
         
         Requires readline.
         
         Example:
         
         [D:\ipython]|1> _ip.set_next_input("Hello Word")
         [D:\ipython]|2> Hello Word_  # cursor is here        
         """
 
         self.IP.rl_next_input = s
 
     def load(self, mod):
         """ Load an extension.
         
         Some modules should (or must) be 'load()':ed, rather than just imported.
         
         Loading will do:
         
         - run init_ipython(ip)
         - run ipython_firstrun(ip)
         
         """
         if mod in self.extensions:
             # just to make sure we don't init it twice
             # note that if you 'load' a module that has already been
             # imported, init_ipython gets run anyway
             
             return self.extensions[mod]
         __import__(mod)
         m = sys.modules[mod]
         if hasattr(m,'init_ipython'):
             m.init_ipython(self)
             
         if hasattr(m,'ipython_firstrun'):
             already_loaded = self.db.get('firstrun_done', set())
             if mod not in already_loaded:
                 m.ipython_firstrun(self)
                 already_loaded.add(mod)
                 self.db['firstrun_done'] = already_loaded
             
         self.extensions[mod] = m
         return m
 
 
 class DebugTools:
     """ Used for debugging mishaps in api usage
     
     So far, tracing redefinitions is supported.
     """
     
     def __init__(self, ip):
         self.ip = ip
         self.debugmode = False
         self.hotnames = set()
         
     def hotname(self, name_to_catch):
         self.hotnames.add(name_to_catch)
         
     def debug_stack(self, msg = None):
         if not self.debugmode:
             return
         
         import traceback
         if msg is not None:
             print '====== %s  ========' % msg
         traceback.print_stack()
 
     def check_hotname(self,name):
         if name in self.hotnames:
             self.debug_stack( "HotName '%s' caught" % name)
 
 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 
     ipython session running.
     
     This is also used as the egg entry point for the 'ipython' script.
     
     """
     ses = make_session(user_ns,shellclass)
     ses.mainloop()
 
 
 def make_user_ns(user_ns = None):
     """Return a valid user interactive namespace.
 
     This builds a dict with the minimal information needed to operate as a
     valid IPython user namespace, which you can pass to the various embedding
     classes in ipython.
     """
 
     if user_ns is None:
         # Set __name__ to __main__ to better match the behavior of the
         # normal interpreter.
         user_ns = {'__name__'     :'__main__',
                    '__builtins__' : __builtin__,
                    }
     else:
         user_ns.setdefault('__name__','__main__')
         user_ns.setdefault('__builtins__',__builtin__)
 
     return user_ns
 
 
 def make_user_global_ns(ns = None):
     """Return a valid user global namespace.
 
     Similar to make_user_ns(), but global namespaces are really only needed in
     embedded applications, where there is a distinction between the user's
     interactive namespace and the global one where ipython is running."""
 
     if ns is None: ns = {}
     return ns
 
 
 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.
 
     Inputs:
 
       - user_ns(None): a dict to be used as the user's namespace with initial
       data.
     
     WARNING: This should *not* be run when a session exists already."""
 
     import IPython.Shell
     if shellclass is None:
         return IPython.Shell.start(user_ns)
     return shellclass(user_ns = user_ns)

doc/examples/leo_bridge_demo.leo

@@ -1,528 +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="180" left="223" height="627" width="1280"/>
+	<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"><vh>Class tests</vh>
+<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.20080222201226"><vh>NewHeadline</vh></v>
 <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" a="TV"><vh>Generate testarr</vh></v>
+<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">1+2
+<t tx="vivainio.20080222201226"># test ipython script 'cleanup' with complex blocks
+1+2
 print "hello"
 3+4
 
 def f(x):
     return x.upper()
 
-f('hello world')
 
 if 0:
     print "foo"
 else:
     print "bar"
 
-</t>
+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>