upstream/ipython Commit - r942:c0885bb7

check for set (python 2.3 compatibility). Closes

vivainio -

r942:c0885bb7

parent child

IPython/Extensions/igrid.py

0 +4 0

             # -*- coding: iso-8859-1 -*-
             import ipipe, os, webbrowser, urllib
             from IPython import ipapi
             import wx
             import wx.grid, wx.html
             try:
                 sorted
             except NameError:
                 from ipipe import sorted
+            try:
+                set
+            except:
+                from sets import Set as set
             __all__ = ["igrid"]
             help = """
             <?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>pickinput (I)</h3>
             <p>Pick the current row as next input line in IPython. Additionally the row is stored as "_"</p>
             <h3>pickinputattr (Shift-I)</h3>
             <p>Pick the attribute under the cursor as next input line in IPython. Additionally the row is stored as "_"</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_expression (CTRL-Shift-F)</h3>
             <p>Find entries matching an expression</p>
             <h3>find_next (F3)</h3>
             <p>Find next occurrence</p>
             <h3>find_previous (Shift-F3)</h3>
             <p>Find previous occurrence</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>refresh_once (R, F5)</h3>
             <p>Refreshes the display by restarting the iterator</p>
             <h3>refresh_every_second</h3>
             <p>Refreshes the display by restarting the iterator every second until stopped by stop_refresh.</p>
             <h3>refresh_interval</h3>
             <p>Refreshes the display by restarting the iterator every X ms (X is a custom interval set by the user) until stopped by stop_refresh.</p>
             <h3>stop_refresh</h3>
             <p>Stops all refresh timers.</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>
             """
             class IGridRenderer(wx.grid.PyGridCellRenderer):
                 """
                 This is a custom renderer for our IGridGrid
                 """
                 def __init__(self, table):
                     self.maxchars = 200
                     self.table = table
                     self.colormap = (
                         (  0,   0,   0),
                         (174,   0,   0),
                         (  0, 174,   0),
                         (174, 174,   0),
                         (  0,   0, 174),
                         (174,   0, 174),
                         (  0, 174, 174),
                         ( 64,  64,  64)
                     )
                     wx.grid.PyGridCellRenderer.__init__(self)
                 def _getvalue(self, row, col):
                     try:
                         value = self.table._displayattrs[col].value(self.table.items[row])
                         (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
                     except Exception, exc:
                         (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
                     return (align, text)
                 def GetBestSize(self, grid, attr, dc, row, col):
                     text = grid.GetCellValue(row, col)
                     (align, text) = self._getvalue(row, col)
                     dc.SetFont(attr.GetFont())
                     (w, h) = dc.GetTextExtent(str(text))
                     return wx.Size(min(w+2, 600), h+2) # add border
                 def Draw(self, grid, attr, dc, rect, row, col, isSelected):
                     """
                     Takes care of drawing everything in the cell; aligns the text
                     """
                     text = grid.GetCellValue(row, col)
                     (align, text) = self._getvalue(row, col)
                     if isSelected:
                         bg = grid.GetSelectionBackground()
                     else:
                         bg = ["white", (240, 240, 240)][row%2]
                     dc.SetTextBackground(bg)
                     dc.SetBrush(wx.Brush(bg, wx.SOLID))
                     dc.SetPen(wx.TRANSPARENT_PEN)
                     dc.SetFont(attr.GetFont())
                     dc.DrawRectangleRect(rect)
                     dc.SetClippingRect(rect)
                     # Format the text
                     if align == -1: # left alignment
                         (width, height) = dc.GetTextExtent(str(text))
                         x = rect[0]+1
                         y = rect[1]+0.5*(rect[3]-height)
                         for (style, part) in text:
                             if isSelected:
                                 fg = grid.GetSelectionForeground()
                             else:
                                 fg = self.colormap[style.fg]
                             dc.SetTextForeground(fg)
                             (w, h) = dc.GetTextExtent(part)
                             dc.DrawText(part, x, y)
                             x += w
                     elif align == 0: # center alignment
                         (width, height) = dc.GetTextExtent(str(text))
                         x = rect[0]+0.5*(rect[2]-width)
                         y = rect[1]+0.5*(rect[3]-height)
                         for (style, part) in text:
                             if isSelected:
                                 fg = grid.GetSelectionForeground()
                             else:
                                 fg = self.colormap[style.fg]
                             dc.SetTextForeground(fg)
                             (w, h) = dc.GetTextExtent(part)
                             dc.DrawText(part, x, y)
                             x += w
                     else:  # right alignment
                         (width, height) = dc.GetTextExtent(str(text))
                         x = rect[0]+rect[2]-1
                         y = rect[1]+0.5*(rect[3]-height)
                         for (style, part) in reversed(text):
                             (w, h) = dc.GetTextExtent(part)
                             x -= w
                             if isSelected:
                                 fg = grid.GetSelectionForeground()
                             else:
                                 fg = self.colormap[style.fg]
                             dc.SetTextForeground(fg)
                             dc.DrawText(part, x, y)
                     dc.DestroyClippingRegion()
                 def Clone(self):
                     return IGridRenderer(self.table)
             class IGridTable(wx.grid.PyGridTableBase):
                 # The data table for the ``IGridGrid``. Some dirty tricks were used here:
                 # ``GetValue()`` does not get any values (or at least it does not return
                 # anything, accessing the values is done by the renderer)
                 # but rather tries to fetch the objects which were requested into the table.
                 # General behaviour is: Fetch the first X objects. If the user scrolls down
                 # to the last object another bunch of X objects is fetched (if possible)
                 def __init__(self, input, fontsize, *attrs):
                     wx.grid.PyGridTableBase.__init__(self)
                     self.input = input
                     self.iterator = ipipe.xiter(input)
                     self.items = []
                     self.attrs = [ipipe.upgradexattr(attr) for attr in attrs]
                     self._displayattrs = self.attrs[:]
                     self._displayattrset = set(self.attrs)
                     self.fontsize = fontsize
                     self._fetch(1)
                     self.timer = wx.Timer()
                     self.timer.Bind(wx.EVT_TIMER, self.refresh_content)
                 def GetAttr(self, *args):
                     attr = wx.grid.GridCellAttr()
                     attr.SetFont(wx.Font(self.fontsize, wx.TELETYPE, wx.NORMAL, wx.NORMAL))
                     return attr
                 def GetNumberRows(self):
                     return len(self.items)
                 def GetNumberCols(self):
                     return len(self._displayattrs)
                 def GetColLabelValue(self, col):
                     if col < len(self._displayattrs):
                         return self._displayattrs[col].name()
                     else:
                         return ""
                 def GetRowLabelValue(self, row):
                     return str(row)
                 def IsEmptyCell(self, row, col):
                     return False
                 def _append(self, item):
                     self.items.append(item)
                     # Nothing to do if the set of attributes has been fixed by the user
                     if not self.attrs:
                         for attr in ipipe.xattrs(item):
                             attr = ipipe.upgradexattr(attr)
                             if attr not in self._displayattrset:
                                 self._displayattrs.append(attr)
                                 self._displayattrset.add(attr)
                 def _fetch(self, count):
                     # Try to fill ``self.items`` with at least ``count`` objects.
                     have = len(self.items)
                     while self.iterator is not None and have < count:
                         try:
                             item = self.iterator.next()
                         except StopIteration:
                             self.iterator = None
                             break
                         except (KeyboardInterrupt, SystemExit):
                             raise
                         except Exception, exc:
                             have += 1
                             self._append(exc)
                             self.iterator = None
                             break
                         else:
                             have += 1
                             self._append(item)
                 def GetValue(self, row, col):
                     # some kind of dummy-function: does not return anything but "";
                     # (The value isn't use anyway)
                     # its main task is to trigger the fetch of new objects
                     sizing_needed = False
                     had_cols = len(self._displayattrs)
                     had_rows = len(self.items)
                     if row == had_rows - 1 and self.iterator is not None:
                         self._fetch(row + 20)
                         sizing_needed = True
                     have_rows = len(self.items)
                     have_cols = len(self._displayattrs)
                     if have_rows > had_rows:
                         msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, have_rows - had_rows)
                         self.GetView().ProcessTableMessage(msg)
                         sizing_needed = True
                     if row >= have_rows:
                         return ""
                     if have_cols != had_cols:
                         msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED, have_cols - had_cols)
                         self.GetView().ProcessTableMessage(msg)
                         sizing_needed = True
                     if sizing_needed:
                         self.GetView().AutoSizeColumns(False)
                     return ""
                 def SetValue(self, row, col, value):
                     pass
                 def refresh_content(self, event):
                     msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, 0, self.GetNumberRows())
                     self.GetView().ProcessTableMessage(msg)
                     self.iterator = ipipe.xiter(self.input)
                     self.items = []
                     self.attrs = [] # _append will calculate new displayattrs
                     self._fetch(1) # fetch one...
                     if self.items:
                         msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
                         self.GetView().ProcessTableMessage(msg)
                         self.GetValue(0, 0) # and trigger "fetch next 20"
                         item = self.items[0]
                         self.GetView().AutoSizeColumns(False)
                         panel = self.GetView().GetParent()
                         nb = panel.GetParent()
                         current = nb.GetSelection()
                         if nb.GetPage(current) == panel:
                             self.GetView().set_footer(item)
             class IGridGrid(wx.grid.Grid):
                 # The actual grid
                 # all methods for selecting/sorting/picking/... data are implemented here
                 def __init__(self, panel, input, *attrs):
                     wx.grid.Grid.__init__(self, panel)
                     fontsize = 9
                     self.input = input
                     self.table = IGridTable(self.input, fontsize, *attrs)
                     self.SetTable(self.table, True)
                     self.SetSelectionMode(wx.grid.Grid.wxGridSelectRows)
                     self.SetDefaultRenderer(IGridRenderer(self.table))
                     self.EnableEditing(False)
                     self.Bind(wx.EVT_KEY_DOWN, self.key_pressed)
                     self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.cell_doubleclicked)
                     self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.cell_leftclicked)
                     self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_DCLICK, self.label_doubleclicked)
                     self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_label_leftclick)
                     self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self._on_selected_range)
                     self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self._on_selected_cell)
                     self.current_selection = set()
                     self.maxchars = 200
                 def on_label_leftclick(self, event):
                     event.Skip()
                 def error_output(self, text):
                     wx.Bell()
                     frame = self.GetParent().GetParent().GetParent()
                     frame.SetStatusText(str(text))
                 def _on_selected_range(self, event):
                     # Internal update to the selection tracking lists
                     if event.Selecting():
                         # adding to the list...
                         self.current_selection.update(xrange(event.GetTopRow(), event.GetBottomRow()+1))
                     else:
                         # removal from list
                         for index in xrange(event.GetTopRow(), event.GetBottomRow()+1):
                             self.current_selection.discard(index)
                     event.Skip()
                 def _on_selected_cell(self, event):
                     # Internal update to the selection tracking list
                     self.current_selection = set([event.GetRow()])
                     event.Skip()
                 def sort(self, key, reverse=False):
                     """
                     Sort the current list of items using the key function ``key``. If
                     ``reverse`` is true the sort order is reversed.
                     """
                     row = self.GetGridCursorRow()
                     col = self.GetGridCursorCol()
                     curitem = self.table.items[row] # Remember where the cursor is now
                     # Sort items
                     def realkey(item):
                         try:
                             return key(item)
                         except (KeyboardInterrupt, SystemExit):
                             raise
                         except Exception:
                             return None
                     try:
                         self.table.items = ipipe.deque(sorted(self.table.items, key=realkey, reverse=reverse))
                     except TypeError, exc:
                         self.error_output("Exception encountered: %s" % exc)
                         return
                     # Find out where the object under the cursor went
                     for (i, item) in enumerate(self.table.items):
                         if item is curitem:
                             self.SetGridCursor(i,col)
                             self.MakeCellVisible(i,col)
                             self.Refresh()
                 def sortattrasc(self):
                     """
                     Sort in ascending order; sorting criteria is the current attribute
                     """
                     col = self.GetGridCursorCol()
                     attr = self.table._displayattrs[col]
                     frame = self.GetParent().GetParent().GetParent()
                     if attr is ipipe.noitem:
                         self.error_output("no column under cursor")
                         return
                     frame.SetStatusText("sort by %s (ascending)" % attr.name())
                     def key(item):
                         try:
                             return attr.value(item)
                         except (KeyboardInterrupt, SystemExit):
                             raise
                         except Exception:
                             return None
                     self.sort(key)
                 def sortattrdesc(self):
                     """
                     Sort in descending order; sorting criteria is the current attribute
                     """
                     col = self.GetGridCursorCol()
                     attr = self.table._displayattrs[col]
                     frame = self.GetParent().GetParent().GetParent()
                     if attr is ipipe.noitem:
                         self.error_output("no column under cursor")
                         return
                     frame.SetStatusText("sort by %s (descending)" % attr.name())
                     def key(item):
                         try:
                             return attr.value(item)
                         except (KeyboardInterrupt, SystemExit):
                             raise
                         except Exception:
                             return None
                     self.sort(key, reverse=True)
                 def label_doubleclicked(self, event):
                     row = event.GetRow()
                     col = event.GetCol()
                     if col == -1:
                         self.enter(row)
                 def _getvalue(self, row, col):
                     """
                     Gets the text which is displayed at ``(row, col)``
                     """
                     try:
                         value = self.table._displayattrs[col].value(self.table.items[row])
                         (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
                     except IndexError:
                         raise IndexError
                     except Exception, exc:
                         (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
                     return text
                 def searchexpression(self, searchexp, startrow=None, search_forward=True ):
                     """
                     Find by expression
                     """
                     frame = self.GetParent().GetParent().GetParent()
                     if searchexp:
                         if search_forward:
                             if not startrow:
                                 row = self.GetGridCursorRow()+1
                             else:
                                 row = startrow + 1
                             while True:
                                 try:
                                     foo = self.table.GetValue(row, 0)
                                     item = self.table.items[row]
                                     try:
                                         globals = ipipe.getglobals(None)
                                         if eval(searchexp, globals, ipipe.AttrNamespace(item)):
                                             self.SetGridCursor(row, 0) # found something
                                             self.MakeCellVisible(row, 0)
                                             break
                                     except (KeyboardInterrupt, SystemExit):
                                         raise
                                     except Exception, exc:
                                         frame.SetStatusText(str(exc))
                                         wx.Bell()
                                         break  # break on error
                                 except IndexError:
                                     return
                                 row += 1
                         else:
                             if not startrow:
                                 row = self.GetGridCursorRow() - 1
                             else:
                                 row = startrow - 1
                             while True:
                                 try:
                                     foo = self.table.GetValue(row, 0)
                                     item = self.table.items[row]
                                     try:
                                         globals = ipipe.getglobals(None)
                                         if eval(searchexp, globals, ipipe.AttrNamespace(item)):
                                             self.SetGridCursor(row, 0) # found something
                                             self.MakeCellVisible(row, 0)
                                             break
                                     except (KeyboardInterrupt, SystemExit):
                                         raise
                                     except Exception, exc:
                                         frame.SetStatusText(str(exc))
                                         wx.Bell()
                                         break  # break on error
                                 except IndexError:
                                     return
                                 row -= 1
                 def search(self, searchtext, startrow=None, startcol=None, search_forward=True):
                     """
                     search for ``searchtext``, starting in ``(startrow, startcol)``;
                     if ``search_forward`` is true the direction is "forward"
                     """
                     searchtext = searchtext.lower()
                     if search_forward:
                         if startrow is not None and startcol is not None:
                             row = startrow
                         else:
                             startcol = self.GetGridCursorCol() + 1
                             row = self.GetGridCursorRow()
                             if startcol >= self.GetNumberCols():
                                 startcol = 0
                                 row += 1
                         while True:
                             for col in xrange(startcol, self.table.GetNumberCols()):
                                 try:
                                     foo = self.table.GetValue(row, col)
                                     text = self._getvalue(row, col)
                                     if searchtext in text.string().lower():
                                         self.SetGridCursor(row, col)
                                         self.MakeCellVisible(row, col)
                                         return
                                 except IndexError:
                                     return
                             startcol = 0
                             row += 1
                     else:
                         if startrow is not None and startcol is not None:
                             row = startrow
                         else:
                             startcol = self.GetGridCursorCol() - 1
                             row = self.GetGridCursorRow()
                             if startcol < 0:
                                 startcol = self.GetNumberCols() - 1
                                 row -= 1
                         while True:
                             for col in xrange(startcol, -1, -1):
                                 try:
                                     foo = self.table.GetValue(row, col)
                                     text = self._getvalue(row, col)
                                     if searchtext in text.string().lower():
                                         self.SetGridCursor(row, col)
                                         self.MakeCellVisible(row, col)
                                         return
                                 except IndexError:
                                     return
                             startcol = self.table.GetNumberCols()-1
                             row -= 1
                 def key_pressed(self, event):
                     """
                     Maps pressed keys to functions
                     """
                     frame = self.GetParent().GetParent().GetParent()
                     frame.SetStatusText("")
                     sh = event.ShiftDown()
                     ctrl = event.ControlDown()
                     keycode = event.GetKeyCode()
                     if keycode == ord("P"):
                         row = self.GetGridCursorRow()
                         if sh:
                             col = self.GetGridCursorCol()
                             self.pickattr(row, col)
                         else:
                             self.pick(row)
                     elif keycode == ord("M"):
                         if ctrl:
                             col = self.GetGridCursorCol()
                             self.pickrowsattr(sorted(self.current_selection), col)
                         else:
                             self.pickrows(sorted(self.current_selection))
                     elif keycode in (wx.WXK_BACK, wx.WXK_DELETE, ord("X")) and not (ctrl or sh):
                         self.delete_current_notebook()
                     elif keycode in (ord("E"), ord("\r")):
                         row = self.GetGridCursorRow()
                         if sh:
                             col = self.GetGridCursorCol()
                             self.enterattr(row, col)
                         else:
                             self.enter(row)
                     elif keycode == ord("E") and ctrl:
                         row = self.GetGridCursorRow()
                         self.SetGridCursor(row, self.GetNumberCols()-1)
                     elif keycode == wx.WXK_HOME or (keycode == ord("A") and ctrl):
                         row = self.GetGridCursorRow()
                         self.SetGridCursor(row, 0)
                     elif keycode == ord("C") and sh:
                         col = self.GetGridCursorCol()
                         attr = self.table._displayattrs[col]
                         result = []
                         for i in xrange(self.GetNumberRows()):
                             result.append(self.table._displayattrs[col].value(self.table.items[i]))
                         self.quit(result)
                     elif keycode in (wx.WXK_ESCAPE, ord("Q")) and not (ctrl or sh):
                         self.quit()
                     elif keycode == ord("<"):
                         row = self.GetGridCursorRow()
                         col = self.GetGridCursorCol()
                         if not event.ShiftDown():
                             newcol = col - 1
                             if newcol >= 0:
                                 self.SetGridCursor(row, col - 1)
                         else:
                             newcol = col + 1
                             if newcol < self.GetNumberCols():
                                 self.SetGridCursor(row, col + 1)
                     elif keycode == ord("D"):
                         col = self.GetGridCursorCol()
                         row = self.GetGridCursorRow()
                         if not sh:
                             self.detail(row, col)
                         else:
                             self.detail_attr(row, col)
                     elif keycode == ord("F") and ctrl:
                         if sh:
                             frame.enter_searchexpression(event)
                         else:
                             frame.enter_searchtext(event)
                     elif keycode == wx.WXK_F3:
                         if sh:
                             frame.find_previous(event)
                         else:
                             frame.find_next(event)
                     elif keycode == ord("V"):
                         if sh:
                             self.sortattrdesc()
                         else:
                             self.sortattrasc()
                     elif keycode == wx.WXK_DOWN:
                         row = self.GetGridCursorRow()
                         try:
                             item = self.table.items[row+1]
                         except IndexError:
                             item = self.table.items[row]
                         self.set_footer(item)
                         event.Skip()
                     elif keycode == wx.WXK_UP:
                         row = self.GetGridCursorRow()
                         if row >= 1:
                             item = self.table.items[row-1]
                         else:
                             item = self.table.items[row]
                         self.set_footer(item)
                         event.Skip()
                     elif keycode == wx.WXK_RIGHT:
                         row = self.GetGridCursorRow()
                         item = self.table.items[row]
                         self.set_footer(item)
                         event.Skip()
                     elif keycode == wx.WXK_LEFT:
                         row = self.GetGridCursorRow()
                         item = self.table.items[row]
                         self.set_footer(item)
                         event.Skip()
                     elif keycode == ord("R") or keycode == wx.WXK_F5:
                         self.table.refresh_content(event)
                     elif keycode == ord("I"):
                         row = self.GetGridCursorRow()
                         if not sh:
                             self.pickinput(row)
                         else:
                             col = self.GetGridCursorCol()
                             self.pickinputattr(row, col)
                     else:
                         event.Skip()
                 def delete_current_notebook(self):
                     """
                     deletes the current notebook tab
                     """
                     panel = self.GetParent()
                     nb = panel.GetParent()
                     current = nb.GetSelection()
                     count = nb.GetPageCount()
                     if count > 1:
                         for i in xrange(count-1, current-1, -1):
                             nb.DeletePage(i)
                         nb.GetCurrentPage().grid.SetFocus()
                     else:
                         frame = nb.GetParent()
                         frame.SetStatusText("This is the last level!")
                 def _doenter(self, value, *attrs):
                     """
                     "enter" a special item resulting in a new notebook tab
                     """
                     panel = self.GetParent()
                     nb = panel.GetParent()
                     frame = nb.GetParent()
                     current = nb.GetSelection()
                     count = nb.GetPageCount()
                     try: # if we want to enter something non-iterable, e.g. a function
                         if current + 1 == count and value is not self.input: # we have an event in the last tab
                             frame._add_notebook(value, *attrs)
                         elif value != self.input: # we have to delete all tabs newer than [panel] first
                             for i in xrange(count-1, current, -1): # some tabs don't close if we don't close in *reverse* order
                                 nb.DeletePage(i)
                             frame._add_notebook(value)
                     except TypeError, exc:
                         if exc.__class__.__module__ == "exceptions":
                             msg = "%s: %s" % (exc.__class__.__name__, exc)
                         else:
                             msg = "%s.%s: %s" % (exc.__class__.__module__, exc.__class__.__name__, exc)
                         frame.SetStatusText(msg)
                 def enterattr(self, row, col):
                     try:
                         attr = self.table._displayattrs[col]
                         value = attr.value(self.table.items[row])
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         self._doenter(value)
                 def set_footer(self, item):
                     frame = self.GetParent().GetParent().GetParent()
                     frame.SetStatusText(" ".join([str(text) for (style, text) in ipipe.xformat(item, "footer", 20)[2]]), 0)
                 def enter(self, row):
                     try:
                         value = self.table.items[row]
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         self._doenter(value)
                 def detail(self, row, col):
                     """
                     shows a detail-view of the current cell
                     """
                     try:
                         attr = self.table._displayattrs[col]
                         item = self.table.items[row]
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
                         self._doenter(attrs)
                 def detail_attr(self, row, col):
                     try:
                         attr = self.table._displayattrs[col]
                         item = attr.value(self.table.items[row])
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
                         self._doenter(attrs)
                 def quit(self, result=None):
                     """
                     quit
                     """
                     frame = self.GetParent().GetParent().GetParent()
                     if frame.helpdialog:
                         frame.helpdialog.Destroy()
                     app = frame.parent
                     if app is not None:
                         app.result = result
                     frame.Close()
                     frame.Destroy()
                 def cell_doubleclicked(self, event):
                     self.enterattr(event.GetRow(), event.GetCol())
                     event.Skip()
                 def cell_leftclicked(self, event):
                     row = event.GetRow()
                     item = self.table.items[row]
                     self.set_footer(item)
                     event.Skip()
                 def pick(self, row):
                     """
                     pick a single row and return to the IPython prompt
                     """
                     try:
                         value = self.table.items[row]
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         self.quit(value)
                 def pickinput(self, row):
                     try:
                         value = self.table.items[row]
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         api = ipapi.get()
                         api.set_next_input(str(value))
                         self.quit(value)
                 def pickinputattr(self, row, col):
                     try:
                         attr = self.table._displayattrs[col]
                         value = attr.value(self.table.items[row])
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         api = ipapi.get()
                         api.set_next_input(str(value))
                         self.quit(value)
                 def pickrows(self, rows):
                     """
                     pick multiple rows and return to the IPython prompt
                     """
                     try:
                         value = [self.table.items[row] for row in rows]
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         self.quit(value)
                 def pickrowsattr(self, rows, col):
                     """"
                     pick one column from multiple rows
                     """
                     values = []
                     try:
                         attr = self.table._displayattrs[col]
                         for row in rows:
                             try:
                                 values.append(attr.value(self.table.items[row]))
                             except (SystemExit, KeyboardInterrupt):
                                 raise
                             except Exception:
                                 raise #pass
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         self.quit(values)
                 def pickattr(self, row, col):
                     try:
                         attr = self.table._displayattrs[col]
                         value = attr.value(self.table.items[row])
                     except Exception, exc:
                         self.error_output(str(exc))
                     else:
                         self.quit(value)
             class IGridPanel(wx.Panel):
                 # Each IGridPanel contains an IGridGrid
                 def __init__(self, parent, input, *attrs):
                     wx.Panel.__init__(self, parent, -1)
                     self.grid = IGridGrid(self, input, *attrs)
                     self.grid.FitInside()
                     sizer = wx.BoxSizer(wx.VERTICAL)
                     sizer.Add(self.grid, proportion=1, flag=wx.EXPAND | wx.ALL, border=10)
                     self.SetSizer(sizer)
                     sizer.Fit(self)
                     sizer.SetSizeHints(self)
             class IGridHTMLHelp(wx.Frame):
                 def __init__(self, parent, title, size):
                     wx.Frame.__init__(self, parent, -1, title, size=size)
                     html = wx.html.HtmlWindow(self)
                     if "gtk2" in wx.PlatformInfo:
                         html.SetStandardFonts()
                     html.SetPage(help)
             class IGridFrame(wx.Frame):
                 maxtitlelen = 30
                 def __init__(self, parent, input):
                     title =  " ".join([str(text) for (style, text) in ipipe.xformat(input, "header", 20)[2]])
                     wx.Frame.__init__(self, None, title=title, size=(640, 480))
                     self.menubar = wx.MenuBar()
                     self.menucounter = 100
                     self.m_help = wx.Menu()
                     self.m_search = wx.Menu()
                     self.m_sort = wx.Menu()
                     self.m_refresh = wx.Menu()
                     self.notebook = wx.Notebook(self, -1, style=0)
                     self.statusbar = self.CreateStatusBar(1, wx.ST_SIZEGRIP)
                     self.statusbar.SetFieldsCount(2)
                     self.SetStatusWidths([-1, 200])
                     self.parent = parent
                     self._add_notebook(input)
                     self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
                     self.makemenu(self.m_sort, "&Sort (asc)\tV", "Sort ascending", self.sortasc)
                     self.makemenu(self.m_sort, "Sort (&desc)\tShift-V", "Sort descending", self.sortdesc)
                     self.makemenu(self.m_help, "&Help\tF1", "Help", self.display_help)
             #        self.makemenu(self.m_help, "&Show help in browser", "Show help in browser", self.display_help_in_browser)
                     self.makemenu(self.m_search, "&Find text\tCTRL-F", "Find text", self.enter_searchtext)
                     self.makemenu(self.m_search, "Find by &expression\tCTRL-Shift-F", "Find by expression", self.enter_searchexpression)
                     self.makemenu(self.m_search, "Find &next\tF3", "Find next", self.find_next)
                     self.makemenu(self.m_search, "Find &previous\tShift-F3", "Find previous", self.find_previous)
                     self.makemenu(self.m_refresh, "&Refresh once \tF5", "Refresh once", self.refresh_once)
                     self.makemenu(self.m_refresh, "Refresh every &1s", "Refresh every second", self.refresh_every_second)
                     self.makemenu(self.m_refresh, "Refresh every &X seconds", "Refresh every X seconds", self.refresh_interval)
                     self.makemenu(self.m_refresh, "&Stop all refresh timers", "Stop refresh timers", self.stop_refresh)
                     self.menubar.Append(self.m_search, "&Find")
                     self.menubar.Append(self.m_sort, "&Sort")
                     self.menubar.Append(self.m_refresh, "&Refresh")
                     self.menubar.Append(self.m_help, "&Help")
                     self.SetMenuBar(self.menubar)
                     self.searchtext = ""
                     self.searchexpression = ""
                     self.helpdialog = None
                     self.refresh_interval = 1000
                     self.SetStatusText("Refreshing inactive", 1)
                 def refresh_once(self, event):
                     table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
                     table.refresh_content(event)
                 def refresh_interval(self, event):
                     table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
                     dlg = wx.TextEntryDialog(self, "Enter refresh interval (milliseconds):", "Refresh timer:", defaultValue=str(self.refresh_interval))
                     if dlg.ShowModal() == wx.ID_OK:
                         try:
                             milliseconds = int(dlg.GetValue())
                         except ValueError, exc:
                             self.SetStatusText(str(exc))
                         else:
                             table.timer.Start(milliseconds=milliseconds, oneShot=False)
                             self.SetStatusText("Refresh timer set to %s ms" % milliseconds)
                             self.SetStatusText("Refresh interval: %s ms" % milliseconds, 1)
                             self.refresh_interval = milliseconds
                     dlg.Destroy()
                 def stop_refresh(self, event):
                     for i in xrange(self.notebook.GetPageCount()):
                         nb = self.notebook.GetPage(i)
                         nb.grid.table.timer.Stop()
                         self.SetStatusText("Refreshing inactive", 1)
                 def refresh_every_second(self, event):
                     table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
                     table.timer.Start(milliseconds=1000, oneShot=False)
                     self.SetStatusText("Refresh interval: 1000 ms", 1)
                 def sortasc(self, event):
                     grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
                     grid.sortattrasc()
                 def sortdesc(self, event):
                     grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
                     grid.sortattrdesc()
                 def find_previous(self, event):
                     """
                     find previous occurrences
                     """
                     grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
                     if self.searchtext:
                         row = grid.GetGridCursorRow()
                         col = grid.GetGridCursorCol()
                         self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
                         if col-1 >= 0:
                             grid.search(self.searchtext, row, col-1, False)
                         else:
                             grid.search(self.searchtext, row-1, grid.table.GetNumberCols()-1, False)
                     elif self.searchexpression:
                         self.SetStatusText("Search mode: expression; looking for %s" % repr(self.searchexpression)[2:-1])
                         grid.searchexpression(searchexp=self.searchexpression, search_forward=False)
                     else:
                         self.SetStatusText("No search yet: please enter search-text or -expression")
                 def find_next(self, event):
                     """
                     find the next occurrence
                     """
                     grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
                     if self.searchtext != "":
                         row = grid.GetGridCursorRow()
                         col = grid.GetGridCursorCol()
                         self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
                         if col+1 < grid.table.GetNumberCols():
                             grid.search(self.searchtext, row, col+1)
                         else:
                             grid.search(self.searchtext, row+1, 0)
                     elif self.searchexpression != "":
                         self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
                         grid.searchexpression(searchexp=self.searchexpression)
                     else:
                         self.SetStatusText("No search yet: please enter search-text or -expression")
                 def display_help(self, event):
                     """
                     Display a help dialog
                     """
                     if self.helpdialog:
                         self.helpdialog.Destroy()
                     self.helpdialog = IGridHTMLHelp(None, title="Help", size=wx.Size(600,400))
                     self.helpdialog.Show()
                 def display_help_in_browser(self, event):
                     """
                     Show the help-HTML in a browser (as a ``HtmlWindow`` does not understand
                     CSS this looks better)
                     """
                     filename = urllib.pathname2url(os.path.abspath(os.path.join(os.path.dirname(__file__), "igrid_help.html")))
                     if not filename.startswith("file"):
                         filename = "file:" + filename
                     webbrowser.open(filename, new=1, autoraise=True)
                 def enter_searchexpression(self, event):
                     dlg = wx.TextEntryDialog(self, "Find:", "Find matching expression:", defaultValue=self.searchexpression)
                     if dlg.ShowModal() == wx.ID_OK:
                         self.searchexpression = dlg.GetValue()
                         self.searchtext = ""
                         self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
                         self.notebook.GetPage(self.notebook.GetSelection()).grid.searchexpression(self.searchexpression)
                     dlg.Destroy()
                 def makemenu(self, menu, label, help, cmd):
                     menu.Append(self.menucounter, label, help)
                     self.Bind(wx.EVT_MENU, cmd, id=self.menucounter)
                     self.menucounter += 1
                 def _add_notebook(self, input, *attrs):
                     # Adds another notebook which has the starting object ``input``
                     panel = IGridPanel(self.notebook, input, *attrs)
                     text = str(ipipe.xformat(input, "header", self.maxtitlelen)[2])
                     if len(text) >= self.maxtitlelen:
                         text = text[:self.maxtitlelen].rstrip(".") + "..."
                     self.notebook.AddPage(panel, text, True)
                     panel.grid.SetFocus()
                     self.Layout()
                 def OnCloseWindow(self, event):
                     self.Destroy()
                 def enter_searchtext(self, event):
                     # Displays a dialog asking for the searchtext
                     dlg = wx.TextEntryDialog(self, "Find:", "Find in list", defaultValue=self.searchtext)
                     if dlg.ShowModal() == wx.ID_OK:
                         self.searchtext = dlg.GetValue()
                         self.searchexpression = ""
                         self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
                         self.notebook.GetPage(self.notebook.GetSelection()).grid.search(self.searchtext)
                     dlg.Destroy()
             class App(wx.App):
                 def __init__(self, input):
                     self.input = input
                     self.result = None # Result to be returned to IPython. Set by quit().
                     wx.App.__init__(self)
                 def OnInit(self):
                     frame = IGridFrame(self, self.input)
                     frame.Show()
                     self.SetTopWindow(frame)
                     frame.Raise()
                     return True
             class igrid(ipipe.Display):
                 """
                 This is a wx-based display object that can be used instead of ``ibrowse``
                 (which is curses-based) or ``idump`` (which simply does a print).
                 """
                 if wx.VERSION < (2, 7):
                     def display(self):
                         try:
                             # Try to create a "standalone" from. If this works we're probably
                             # running with -wthread.
                             # Note that this sets the parent of the frame to None, but we can't
                             # pass a result object back to the shell anyway.
                             frame = IGridFrame(None, self.input)
                             frame.Show()
                             frame.Raise()
                         except wx.PyNoAppError:
                             # There's no wx application yet => create one.
                             app = App(self.input)
                             app.MainLoop()
                             return app.result
                 else:
                     # With wx 2.7 it gets simpler.
                     def display(self):
                         app = App(self.input)
                         app.MainLoop()
                         return app.result

IPython/Extensions/ipy_completers.py

0 +5 0

             #!/usr/bin/env python
             """ Implementations for various useful completers
             See Extensions/ipy_stock_completers.py on examples of how to enable a completer,
             but the basic idea is to do:
             ip.set_hook('complete_command', svn_completer, str_key = 'svn')
             """
             import IPython.ipapi
             import glob,os,shlex,sys
             import inspect
             from time import time
             ip = IPython.ipapi.get()
+            try:
+                set
+            except:
+                from sets import Set as set
             TIMEOUT_STORAGE = 3 #Time in seconds after which the rootmodules will be stored
             TIMEOUT_GIVEUP = 20 #Time in seconds after which we give up
             def quick_completer(cmd, completions):
                 """ Easily create a trivial completer for a command.
                 Takes either a list of completions, or all completions in string
                 (that will be split on whitespace)
                 Example::
                     [d:\ipython]|1> import ipy_completers
                     [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])
                     [d:\ipython]|3> foo b<TAB>
                     bar baz
                     [d:\ipython]|3> foo ba
                 """
                 if isinstance(completions, basestring):
                     completions = completions.split()
                 def do_complete(self,event):
                     return completions
                 ip.set_hook('complete_command',do_complete, str_key = cmd)
             def getRootModules():
                 """
                 Returns a list containing the names of all the modules available in the
                 folders of the pythonpath.
                 """
                 modules = []
                 if ip.db.has_key('rootmodules'):
                     return ip.db['rootmodules']
                 t = time()
                 store = False
                 for path in sys.path:
                     modules += moduleList(path)
                     if time() - t >= TIMEOUT_STORAGE and not store:
                         store = True
                         print "\nCaching the list of root modules, please wait!"
                         print "(This will only be done once - type '%rehashx' to " + \
                         "reset cache!)"
                         print
                     if time() - t > TIMEOUT_GIVEUP:
                         print "This is taking too long, we give up."
                         print
                         ip.db['rootmodules'] = []
                         return []
                 modules += sys.builtin_module_names
                 modules = list(set(modules))
                 if '__init__' in modules:
                     modules.remove('__init__')
                 modules = list(set(modules))
                 if store:
                     ip.db['rootmodules'] = modules
                 return modules
             def moduleList(path):
                 """
                 Return the list containing the names of the modules available in the given
                 folder.
                 """
                 if os.path.isdir(path):
                     folder_list = os.listdir(path)
                 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')]
                 folder_list = [os.path.basename(p).split('.')[0] for p in folder_list]
                 return folder_list
             def moduleCompletion(line):
                 """
                 Returns a list containing the completion possibilities for an import line.
                 The line looks like this :
                 'import xml.d'
                 'from xml.dom import'
                 """
                 def tryImport(mod, only_modules=False):
                     def isImportable(module, attr):
                         if only_modules:
                             return inspect.ismodule(getattr(module, attr))
                         else:
                             return not(attr[:2] == '__' and attr[-2:] == '__')
                     try:
                         m = __import__(mod)
                     except:
                         return []
                     mods = mod.split('.')
                     for module in mods[1:]:
                         m = getattr(m,module)
                     if (not hasattr(m, '__file__')) or (not only_modules) or\
                        (hasattr(m, '__file__') and '__init__' in m.__file__):
                         completion_list = [attr for attr in dir(m) if isImportable(m, attr)]
                     completion_list.extend(getattr(m,'__all__',[]))
                     if hasattr(m, '__file__') and '__init__' in m.__file__:
                         completion_list.extend(moduleList(os.path.dirname(m.__file__)))
                     completion_list = list(set(completion_list))
                     if '__init__' in completion_list:
                         completion_list.remove('__init__')
                     return completion_list
                 words = line.split(' ')
                 if len(words) == 3 and words[0] == 'from':
                     return ['import ']
                 if len(words) < 3 and (words[0] in ['import','from']) :
                     if len(words) == 1:
                         return getRootModules()
                     mod = words[1].split('.')
                     if len(mod) < 2:
                         return getRootModules()
                     completion_list = tryImport('.'.join(mod[:-1]), True)
                     completion_list = ['.'.join(mod[:-1] + [el]) for el in completion_list]
                     return completion_list
                 if len(words) >= 3 and words[0] == 'from':
                     mod = words[1]
                     return tryImport(mod)
             def vcs_completer(commands, event):
                 """ utility to make writing typical version control app completers easier
                 VCS command line apps typically have the format:
                 [sudo ]PROGNAME [help] [command] file file...
                 """
                 cmd_param = event.line.split()
                 if event.line.endswith(' '):
                     cmd_param.append('')
                 if cmd_param[0] == 'sudo':
                     cmd_param = cmd_param[1:]
                 if len(cmd_param) == 2 or 'help' in cmd_param:
                     return commands.split()
                 return ip.IP.Completer.file_matches(event.symbol)
             pkg_cache = None
             def module_completer(self,event):
                 """ Give completions after user has typed 'import ...' or 'from ...'"""
                 # This works in all versions of python.  While 2.5 has
                 # pkgutil.walk_packages(), that particular routine is fairly dangerous,
                 # since it imports *EVERYTHING* on sys.path.  That is: a) very slow b) full
                 # of possibly problematic side effects.
                 # This search the folders in the sys.path for available modules.
                 return moduleCompletion(event.line)
             svn_commands = """\
             add blame praise annotate ann cat checkout co cleanup commit ci copy
             cp delete del remove rm diff di export help ? h import info list ls
             lock log merge mkdir move mv rename ren propdel pdel pd propedit pedit
             pe propget pget pg proplist plist pl propset pset ps resolved revert
             status stat st switch sw unlock update
             """
             def svn_completer(self,event):
                 return vcs_completer(svn_commands, event)
             hg_commands = """
             add addremove annotate archive backout branch branches bundle cat
             clone commit copy diff export grep heads help identify import incoming
             init locate log manifest merge outgoing parents paths pull push
             qapplied qclone qcommit qdelete qdiff qfold qguard qheader qimport
             qinit qnew qnext qpop qprev qpush qrefresh qrename qrestore qsave
             qselect qseries qtop qunapplied recover remove rename revert rollback
             root serve showconfig status strip tag tags tip unbundle update verify
             version
             """
             def hg_completer(self,event):
                 """ Completer for mercurial commands """
                 return vcs_completer(hg_commands, 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
             """
             def bzr_completer(self,event):
                 """ Completer for bazaar commands """
                 cmd_param = event.line.split()
                 if event.line.endswith(' '):
                     cmd_param.append('')
                 if len(cmd_param) > 2:
                     cmd = cmd_param[1]
                     param = cmd_param[-1]
                     output_file = (param == '--output=')
                     if cmd == 'help':
                         return bzr_commands.split()
                     elif cmd in ['bundle-revisions','conflicts',
                                  'deleted','nick','register-branch',
                                  'serve','unbind','upgrade','version',
                                  'whoami'] and not output_file:
                         return []
                     else:
                         # the rest are probably file names
                         return ip.IP.Completer.file_matches(event.symbol)
                 return bzr_commands.split()
             def shlex_split(x):
                 """Helper function to split lines into segments."""
                 #shlex.split raise exception if syntax error in sh syntax
                 #for example if no closing " is found. This function keeps dropping
                 #the last character of the line until shlex.split does not raise
                 #exception. Adds end of the line to the result of shlex.split
                 #example: %run "c:/python  -> ['%run','"c:/python']
                 endofline=[]
                 while x!="":
                     try:
                         comps=shlex.split(x)
                         if len(endofline)>=1:
                             comps.append("".join(endofline))
                         return comps
                     except ValueError:
                         endofline=[x[-1:]]+endofline
                         x=x[:-1]
                 return ["".join(endofline)]
             def runlistpy(self, event):
                 comps = shlex_split(event.line)
                 relpath = (len(comps) > 1 and comps[-1] or '').strip("'\"")
                 #print "\nev=",event  # dbg
                 #print "rp=",relpath  # dbg
                 #print 'comps=',comps  # dbg
                 lglob = glob.glob
                 isdir = os.path.isdir
                 if relpath.startswith('~'):
                     relpath = os.path.expanduser(relpath)
                 dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*')
                         if isdir(f)]
                 # Find if the user has already typed the first filename, after which we
                 # should complete on all files, since after the first one other files may
                 # be arguments to the input script.
                 #filter(
                 if filter(lambda f: f.endswith('.py') or f.endswith('.ipy'),comps):
                     pys =  [f.replace('\\','/') for f in lglob('*')]
                 else:
                     pys =  [f.replace('\\','/')
                             for f in lglob(relpath+'*.py') + lglob(relpath+'*.ipy')]
                 return dirs + pys
             def cd_completer(self, event):
                 relpath = event.symbol
                 #print event # dbg
                 if '-b' in event.line:
                     # return only bookmark completions
                     bkms = self.db.get('bookmarks',{})
                     return bkms.keys()
                 if event.symbol == '-':
                     width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
                     # jump in directory history by number
                     fmt = '-%0' + width_dh +'d [%s]'
                     ents = [ fmt % (i,s) for i,s in enumerate(ip.user_ns['_dh'])]
                     if len(ents) > 1:
                         return ents
                     return []
                 if relpath.startswith('~'):
                     relpath = os.path.expanduser(relpath).replace('\\','/')
                 found = []
                 for d in [f.replace('\\','/') + '/' for f in glob.glob(relpath+'*')
                           if os.path.isdir(f)]:
                     if ' ' in d:
                         # we don't want to deal with any of that, complex code
                         # for this is elsewhere
                         raise IPython.ipapi.TryNext
                     found.append( d )
                 if not found:
                     if os.path.isdir(relpath):
                         return [relpath]
                     raise IPython.ipapi.TryNext
                 return found
             def apt_get_packages(prefix):
                 out = os.popen('apt-cache pkgnames')
                 for p in out:
                     if p.startswith(prefix):
                         yield p.rstrip()
             apt_commands = """\
             update upgrade install remove purge source build-dep dist-upgrade
             dselect-upgrade clean autoclean check"""
             def apt_completer(self, event):
                 """ Completer for apt-get (uses apt-cache internally)
                 """
                 cmd_param = event.line.split()
                 if event.line.endswith(' '):
                     cmd_param.append('')
                 if cmd_param[0] == 'sudo':
                     cmd_param = cmd_param[1:]
                 if len(cmd_param) == 2 or 'help' in cmd_param:
                     return apt_commands.split()
                 return list(apt_get_packages(event.symbol))

IPython/Extensions/ipy_traits_completer.py

0 +4 0

             """Traits-aware tab completion.
             This module provides a custom tab-completer that intelligently hides the names
             that the enthought.traits library (http://code.enthought.com/traits)
             automatically adds to all objects that inherit from its base HasTraits class.
             Activation
             ==========
             To use this, put in your ~/.ipython/ipy_user_conf.py file:
                 from ipy_traits_completer import activate
                 activate([complete_threshold])
             The optional complete_threshold argument is the minimal length of text you need
             to type for tab-completion to list names that are automatically generated by
             traits.  The default value is 3.  Note that at runtime, you can change this
             value simply by doing:
                 import ipy_traits_completer
                 ipy_traits_completer.COMPLETE_THRESHOLD = 4
             Usage
             =====
             The system works as follows.  If t is an empty object that HasTraits, then
             (assuming the threshold is at the default value of 3):
             In [7]: t.ed<TAB>
             doesn't show anything at all, but:
             In [7]: t.edi<TAB>
             t.edit_traits      t.editable_traits
             shows these two names that come from traits.  This allows you to complete on
             the traits-specific names by typing at least 3 letters from them (or whatever
             you set your threshold to), but to otherwise not see them in normal completion.
             Notes
             =====
               - This requires Python 2.4 to work (I use sets).  I don't think anyone is
               using traits with 2.3 anyway, so that's OK.
             """
             #############################################################################
             # External imports
             from enthought.traits import api as T
             # IPython imports
             from IPython.ipapi import TryNext, get as ipget
             from IPython.genutils import dir2
+            try:
+                set
+            except:
+                from sets import Set as set
             #############################################################################
             # Module constants
             # The completion threshold
             # This is currently implemented as a module global, since this sytem isn't
             # likely to be modified at runtime by multiple instances.  If needed in the
             # future, we can always make it local to the completer as a function attribute.
             COMPLETE_THRESHOLD = 3
             # Set of names that Traits automatically adds to ANY traits-inheriting object.
             # These are the names we'll filter out.
             TRAIT_NAMES = set( dir2(T.HasTraits()) ) - set( dir2(object()) )
             #############################################################################
             # Code begins
             def trait_completer(self,event):
                 """A custom IPython tab-completer that is traits-aware.
                 It tries to hide the internal traits attributes, and reveal them only when
                 it can reasonably guess that the user really is after one of them.
                 """
                 #print '\nevent is:',event  # dbg
                 symbol_parts = event.symbol.split('.')
                 base = '.'.join(symbol_parts[:-1])
                 #print 'base:',base  # dbg
                 oinfo = self._ofind(base)
                 if not oinfo['found']:
                     raise TryNext
                 obj = oinfo['obj']
                 # OK, we got the object.  See if it's traits, else punt
                 if not isinstance(obj,T.HasTraits):
                     raise TryNext
                 # it's a traits object, don't show the tr* attributes unless the completion
                 # begins with 'tr'
                 attrs = dir2(obj)
                 # Now, filter out the attributes that start with the user's request
                 attr_start = symbol_parts[-1]
                 if attr_start:
                     attrs = [a for a in attrs if a.startswith(attr_start)]
                 # Let's also respect the user's readline_omit__names setting:
                 omit__names = ipget().options.readline_omit__names
                 if omit__names == 1:
                     attrs = [a for a in attrs if not a.startswith('__')]
                 elif omit__names == 2:
                     attrs = [a for a in attrs if not a.startswith('_')]
                 #print '\nastart:<%r>' % attr_start  # dbg
                 if len(attr_start)<COMPLETE_THRESHOLD:
                     attrs = list(set(attrs) - TRAIT_NAMES)
                 # The base of the completion, so we can form the final results list
                 bdot = base+'.'
                 tcomp = [bdot+a for a in attrs]
                 #print 'tcomp:',tcomp
                 return tcomp
             def activate(complete_threshold = COMPLETE_THRESHOLD):
                 """Activate the Traits completer.
                 :Keywords:
                   complete_threshold : int
                     The minimum number of letters that a user must type in order to
                   activate completion of traits-private names."""
                 if not (isinstance(complete_threshold,int) and
                         complete_threshold>0):
                     e='complete_threshold must be a positive integer, not %r'  % \
                        complete_threshold
                     raise ValueError(e)
                 # Set the module global
                 global COMPLETE_THRESHOLD
                 COMPLETE_THRESHOLD = complete_threshold
                 # Activate the traits aware completer
                 ip = ipget()
                 ip.set_hook('complete_command', trait_completer, re_key = '.*')
             #############################################################################
             if __name__ == '__main__':
                 # Testing/debugging
                 # A sorted list of the names we'll filter out
                 TNL = list(TRAIT_NAMES)
                 TNL.sort()
                 # Make a few objects for testing
                 class TClean(T.HasTraits): pass
                 class Bunch(object): pass
                 # A clean traits object
                 t = TClean()
                 # A nested object containing t
                 f = Bunch()
                 f.t = t
                 # And a naked new-style object
                 o = object()
                 ip = ipget().IP
                 # A few simplistic tests
                 # Reset the threshold to the default, in case the test is running inside an
                 # instance of ipython that changed it
                 import ipy_traits_completer
                 ipy_traits_completer.COMPLETE_THRESHOLD = 3
                 assert ip.complete('t.ed') ==[]
                 # For some bizarre reason, these fail on the first time I run them, but not
                 # afterwards.  Traits does some really weird stuff at object instantiation
                 # time...
                 ta = ip.complete('t.edi')
                 assert ta == ['t.edit_traits', 't.editable_traits']
                 print 'Tests OK'

IPython/genutils.py

0 +7 -1

             # -*- coding: utf-8 -*-
             """
             General purpose utilities.
             This is a grab-bag of stuff I find useful in most programs I write. Some of
             these things are also convenient when working at the command line.
-            $Id: genutils.py 2888 2007-12-12 17:20:42Z vivainio $"""
+            $Id: genutils.py 2937 2008-01-16 15:25:59Z vivainio $"""
             #*****************************************************************************
             #       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
             #
             #  Distributed under the terms of the BSD License.  The full license is in
             #  the file COPYING, distributed as part of this software.
             #*****************************************************************************
             from IPython import Release
             __author__  = '%s <%s>' % Release.authors['Fernando']
             __license__ = Release.license
             #****************************************************************************
             # required modules from the Python standard library
             import __main__
             import commands
             import doctest
             import os
             import re
             import shlex
             import shutil
             import sys
             import tempfile
             import time
             import types
             import warnings
             # Other IPython utilities
             import IPython
             from IPython.Itpl import Itpl,itpl,printpl
             from IPython import DPyGetOpt, platutils
             from IPython.generics import result_display
             from path import path
             if os.name == "nt":
                 from IPython.winconsole import get_console_size
+            try:
+                set
+            except:
+                from sets import Set as set
             #****************************************************************************
             # Exceptions
             class Error(Exception):
                 """Base class for exceptions in this module."""
                 pass
             #----------------------------------------------------------------------------
             class IOStream:
                 def __init__(self,stream,fallback):
                     if not hasattr(stream,'write') or not hasattr(stream,'flush'):
                         stream = fallback
                     self.stream = stream
                     self._swrite = stream.write
                     self.flush = stream.flush
                 def write(self,data):
                     try:
                         self._swrite(data)
                     except:
                         try:
                             # print handles some unicode issues which may trip a plain
                             # write() call.  Attempt to emulate write() by using a
                             # trailing comma
                             print >> self.stream, data,
                         except:
                             # if we get here, something is seriously broken.
                             print >> sys.stderr, \
                                   'ERROR - failed to write data to stream:', self.stream
                 def close(self):
                     pass
             class IOTerm:
                 """ Term holds the file or file-like objects for handling I/O operations.
                 These are normally just sys.stdin, sys.stdout and sys.stderr but for
                 Windows they can can replaced to allow editing the strings before they are
                 displayed."""
                 # In the future, having IPython channel all its I/O operations through
                 # this class will make it easier to embed it into other environments which
                 # are not a normal terminal (such as a GUI-based shell)
                 def __init__(self,cin=None,cout=None,cerr=None):
                     self.cin  = IOStream(cin,sys.stdin)
                     self.cout = IOStream(cout,sys.stdout)
                     self.cerr = IOStream(cerr,sys.stderr)
             # Global variable to be used for all I/O
             Term = IOTerm()
             import IPython.rlineimpl as readline
             # Remake Term to use the readline i/o facilities
             if sys.platform == 'win32' and readline.have_readline:
                 Term = IOTerm(cout=readline._outputfile,cerr=readline._outputfile)
             #****************************************************************************
             # Generic warning/error printer, used by everything else
             def warn(msg,level=2,exit_val=1):
                 """Standard warning printer. Gives formatting consistency.
                 Output is sent to Term.cerr (sys.stderr by default).
                 Options:
                 -level(2): allows finer control:
 -> Do nothing, dummy function.
 -> Print message.
 -> Print 'WARNING:' + message. (Default level).
 -> Print 'ERROR:' + message.
 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
                 -exit_val (1): exit value returned by sys.exit() for a level 4
                 warning. Ignored for all other levels."""
                 if level>0:
                     header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
                     print >> Term.cerr, '%s%s' % (header[level],msg)
                     if level == 4:
                         print >> Term.cerr,'Exiting.\n'
                         sys.exit(exit_val)
             def info(msg):
                 """Equivalent to warn(msg,level=1)."""
                 warn(msg,level=1)
             def error(msg):
                 """Equivalent to warn(msg,level=3)."""
                 warn(msg,level=3)
             def fatal(msg,exit_val=1):
                 """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
                 warn(msg,exit_val=exit_val,level=4)
             #---------------------------------------------------------------------------
             # Debugging routines
             #
             def debugx(expr,pre_msg=''):
                 """Print the value of an expression from the caller's frame.
                 Takes an expression, evaluates it in the caller's frame and prints both
                 the given expression and the resulting value (as well as a debug mark
                 indicating the name of the calling function.  The input must be of a form
                 suitable for eval().
                 An optional message can be passed, which will be prepended to the printed
                 expr->value pair."""
                 cf = sys._getframe(1)
                 print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
                                                eval(expr,cf.f_globals,cf.f_locals))
             # deactivate it by uncommenting the following line, which makes it a no-op
             #def debugx(expr,pre_msg=''): pass
             #----------------------------------------------------------------------------
             StringTypes = types.StringTypes
             # Basic timing functionality
             # If possible (Unix), use the resource module instead of time.clock()
             try:
                 import resource
                 def clocku():
                     """clocku() -> floating point number
                     Return the *USER* CPU time in seconds since the start of the process.
                     This is done via a call to resource.getrusage, so it avoids the
                     wraparound problems in time.clock()."""
                     return resource.getrusage(resource.RUSAGE_SELF)[0]
                 def clocks():
                     """clocks() -> floating point number
                     Return the *SYSTEM* CPU time in seconds since the start of the process.
                     This is done via a call to resource.getrusage, so it avoids the
                     wraparound problems in time.clock()."""
                     return resource.getrusage(resource.RUSAGE_SELF)[1]
                 def clock():
                     """clock() -> floating point number
                     Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
                     the process.  This is done via a call to resource.getrusage, so it
                     avoids the wraparound problems in time.clock()."""
                     u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
                     return u+s
                 def clock2():
                     """clock2() -> (t_user,t_system)
                     Similar to clock(), but return a tuple of user/system times."""
                     return resource.getrusage(resource.RUSAGE_SELF)[:2]
             except ImportError:
                 # There is no distinction of user/system time under windows, so we just use
                 # time.clock() for everything...
                 clocku = clocks = clock = time.clock
                 def clock2():
                     """Under windows, system CPU time can't be measured.
                     This just returns clock() and zero."""
                     return time.clock(),0.0
             def timings_out(reps,func,*args,**kw):
                 """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
                 Execute a function reps times, return a tuple with the elapsed total
                 CPU time in seconds, the time per call and the function's output.
                 Under Unix, the return value is the sum of user+system time consumed by
                 the process, computed via the resource module.  This prevents problems
                 related to the wraparound effect which the time.clock() function has.
                 Under Windows the return value is in wall clock seconds. See the
                 documentation for the time module for more details."""
                 reps = int(reps)
                 assert reps >=1, 'reps must be >= 1'
                 if reps==1:
                     start = clock()
                     out = func(*args,**kw)
                     tot_time = clock()-start
                 else:
                     rng = xrange(reps-1) # the last time is executed separately to store output
                     start = clock()
                     for dummy in rng: func(*args,**kw)
                     out = func(*args,**kw)  # one last time
                     tot_time = clock()-start
                 av_time = tot_time / reps
                 return tot_time,av_time,out
             def timings(reps,func,*args,**kw):
                 """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
                 Execute a function reps times, return a tuple with the elapsed total CPU
                 time in seconds and the time per call. These are just the first two values
                 in timings_out()."""
                 return timings_out(reps,func,*args,**kw)[0:2]
             def timing(func,*args,**kw):
                 """timing(func,*args,**kw) -> t_total
                 Execute a function once, return the elapsed total CPU time in
                 seconds. This is just the first value in timings_out()."""
                 return timings_out(1,func,*args,**kw)[0]
             #****************************************************************************
             # file and system
             def arg_split(s,posix=False):
                 """Split a command line's arguments in a shell-like manner.
                 This is a modified version of the standard library's shlex.split()
                 function, but with a default of posix=False for splitting, so that quotes
                 in inputs are respected."""
                 # XXX - there may be unicode-related problems here!!!  I'm not sure that
                 # shlex is truly unicode-safe, so it might be necessary to do
                 #
                 # s = s.encode(sys.stdin.encoding)
                 #
                 # first, to ensure that shlex gets a normal string.  Input from anyone who
                 # knows more about unicode and shlex than I would be good to have here...
                 lex = shlex.shlex(s, posix=posix)
                 lex.whitespace_split = True
                 return list(lex)
             def system(cmd,verbose=0,debug=0,header=''):
                 """Execute a system command, return its exit status.
                 Options:
                 - verbose (0): print the command to be executed.
                 - debug (0): only print, do not actually execute.
                 - header (''): Header to print on screen prior to the executed command (it
                 is only prepended to the command, no newlines are added).
                 Note: a stateful version of this function is available through the
                 SystemExec class."""
                 stat = 0
                 if verbose or debug: print header+cmd
                 sys.stdout.flush()
                 if not debug: stat = os.system(cmd)
                 return stat
             def abbrev_cwd():
                 """ Return abbreviated version of cwd, e.g. d:mydir """
                 cwd = os.getcwd().replace('\\','/')
                 drivepart = ''
                 tail = cwd
                 if sys.platform == 'win32':
                     if len(cwd) < 4:
                         return cwd
                     drivepart,tail = os.path.splitdrive(cwd)
                 parts = tail.split('/')
                 if len(parts) > 2:
                     tail = '/'.join(parts[-2:])
                 return (drivepart + (
                     cwd == '/' and '/' or tail))
             # This function is used by ipython in a lot of places to make system calls.
             # We need it to be slightly different under win32, due to the vagaries of
             # 'network shares'.  A win32 override is below.
             def shell(cmd,verbose=0,debug=0,header=''):
                 """Execute a command in the system shell, always return None.
                 Options:
                 - verbose (0): print the command to be executed.
                 - debug (0): only print, do not actually execute.
                 - header (''): Header to print on screen prior to the executed command (it
                 is only prepended to the command, no newlines are added).
                 Note: this is similar to genutils.system(), but it returns None so it can
                 be conveniently used in interactive loops without getting the return value
                 (typically 0) printed many times."""
                 stat = 0
                 if verbose or debug: print header+cmd
                 # flush stdout so we don't mangle python's buffering
                 sys.stdout.flush()
                 if not debug:
                     platutils.set_term_title("IPy " + cmd)
                     os.system(cmd)
                     platutils.set_term_title("IPy " + abbrev_cwd())
             # override shell() for win32 to deal with network shares
             if os.name in ('nt','dos'):
                 shell_ori = shell
                 def shell(cmd,verbose=0,debug=0,header=''):
                     if os.getcwd().startswith(r"\\"):
                         path = os.getcwd()
                         # change to c drive (cannot be on UNC-share when issuing os.system,
                         # as cmd.exe cannot handle UNC addresses)
                         os.chdir("c:")
                         # issue pushd to the UNC-share and then run the command
                         try:
                             shell_ori('"pushd %s&&"'%path+cmd,verbose,debug,header)
                         finally:
                             os.chdir(path)
                     else:
                         shell_ori(cmd,verbose,debug,header)
                 shell.__doc__ = shell_ori.__doc__
             def getoutput(cmd,verbose=0,debug=0,header='',split=0):
                 """Dummy substitute for perl's backquotes.
                 Executes a command and returns the output.
                 Accepts the same arguments as system(), plus:
                 - split(0): if true, the output is returned as a list split on newlines.
                 Note: a stateful version of this function is available through the
                 SystemExec class.
                 This is pretty much deprecated and rarely used,
                 genutils.getoutputerror may be what you need.
                 """
                 if verbose or debug: print header+cmd
                 if not debug:
                     output = os.popen(cmd).read()
                     # stipping last \n is here for backwards compat.
                     if output.endswith('\n'):
                         output = output[:-1]
                     if split:
                         return output.split('\n')
                     else:
                         return output
             def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
                 """Return (standard output,standard error) of executing cmd in a shell.
                 Accepts the same arguments as system(), plus:
                 - split(0): if true, each of stdout/err is returned as a list split on
                 newlines.
                 Note: a stateful version of this function is available through the
                 SystemExec class."""
                 if verbose or debug: print header+cmd
                 if not cmd:
                     if split:
                         return [],[]
                     else:
                         return '',''
                 if not debug:
                     pin,pout,perr = os.popen3(cmd)
                     tout = pout.read().rstrip()
                     terr = perr.read().rstrip()
                     pin.close()
                     pout.close()
                     perr.close()
                     if split:
                         return tout.split('\n'),terr.split('\n')
                     else:
                         return tout,terr
             # for compatibility with older naming conventions
             xsys = system
             bq = getoutput
             class SystemExec:
                 """Access the system and getoutput functions through a stateful interface.
                 Note: here we refer to the system and getoutput functions from this
                 library, not the ones from the standard python library.
                 This class offers the system and getoutput functions as methods, but the
                 verbose, debug and header parameters can be set for the instance (at
                 creation time or later) so that they don't need to be specified on each
                 call.
                 For efficiency reasons, there's no way to override the parameters on a
                 per-call basis other than by setting instance attributes. If you need
                 local overrides, it's best to directly call system() or getoutput().
                 The following names are provided as alternate options:
                  - xsys: alias to system
                  - bq: alias to getoutput
                 An instance can then be created as:
                  >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
                 And used as:
                  >>> sysexec.xsys('pwd')
                  >>> dirlist = sysexec.bq('ls -l')
                 """
                 def __init__(self,verbose=0,debug=0,header='',split=0):
                     """Specify the instance's values for verbose, debug and header."""
                     setattr_list(self,'verbose debug header split')
                 def system(self,cmd):
                     """Stateful interface to system(), with the same keyword parameters."""
                     system(cmd,self.verbose,self.debug,self.header)
                 def shell(self,cmd):
                     """Stateful interface to shell(), with the same keyword parameters."""
                     shell(cmd,self.verbose,self.debug,self.header)
                 xsys = system  # alias
                 def getoutput(self,cmd):
                     """Stateful interface to getoutput()."""
                     return getoutput(cmd,self.verbose,self.debug,self.header,self.split)
                 def getoutputerror(self,cmd):
                     """Stateful interface to getoutputerror()."""
                     return getoutputerror(cmd,self.verbose,self.debug,self.header,self.split)
                 bq = getoutput  # alias
             #-----------------------------------------------------------------------------
             def mutex_opts(dict,ex_op):
                 """Check for presence of mutually exclusive keys in a dict.
                 Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
                 for op1,op2 in ex_op:
                     if op1 in dict and op2 in dict:
                         raise ValueError,'\n*** ERROR in Arguments *** '\
                               'Options '+op1+' and '+op2+' are mutually exclusive.'
             #-----------------------------------------------------------------------------
             def get_py_filename(name):
                 """Return a valid python filename in the current directory.
                 If the given name is not a file, it adds '.py' and searches again.
                 Raises IOError with an informative message if the file isn't found."""
                 name = os.path.expanduser(name)
                 if not os.path.isfile(name) and not name.endswith('.py'):
                     name += '.py'
                 if os.path.isfile(name):
                     return name
                 else:
                     raise IOError,'File `%s` not found.' % name
             #-----------------------------------------------------------------------------
             def filefind(fname,alt_dirs = None):
                 """Return the given filename either in the current directory, if it
                 exists, or in a specified list of directories.
                 ~ expansion is done on all file and directory names.
                 Upon an unsuccessful search, raise an IOError exception."""
                 if alt_dirs is None:
                     try:
                         alt_dirs = get_home_dir()
                     except HomeDirError:
                         alt_dirs = os.getcwd()
                 search = [fname] + list_strings(alt_dirs)
                 search = map(os.path.expanduser,search)
                 #print 'search list for',fname,'list:',search  # dbg
                 fname = search[0]
                 if os.path.isfile(fname):
                     return fname
                 for direc in search[1:]:
                     testname = os.path.join(direc,fname)
                     #print 'testname',testname  # dbg
                     if os.path.isfile(testname):
                         return testname
                 raise IOError,'File' + `fname` + \
                       ' not found in current or supplied directories:' + `alt_dirs`
             #----------------------------------------------------------------------------
             def file_read(filename):
                 """Read a file and close it.  Returns the file source."""
                 fobj = open(filename,'r');
                 source = fobj.read();
                 fobj.close()
                 return source
             def file_readlines(filename):
                 """Read a file and close it.  Returns the file source using readlines()."""
                 fobj = open(filename,'r');
                 lines = fobj.readlines();
                 fobj.close()
                 return lines
             #----------------------------------------------------------------------------
             def target_outdated(target,deps):
                 """Determine whether a target is out of date.
                 target_outdated(target,deps) -> 1/0
                 deps: list of filenames which MUST exist.
                 target: single filename which may or may not exist.
                 If target doesn't exist or is older than any file listed in deps, return
                 true, otherwise return false.
                 """
                 try:
                     target_time = os.path.getmtime(target)
                 except os.error:
                     return 1
                 for dep in deps:
                     dep_time = os.path.getmtime(dep)
                     if dep_time > target_time:
                         #print "For target",target,"Dep failed:",dep # dbg
                         #print "times (dep,tar):",dep_time,target_time # dbg
                         return 1
                 return 0
             #-----------------------------------------------------------------------------
             def target_update(target,deps,cmd):
                 """Update a target with a given command given a list of dependencies.
                 target_update(target,deps,cmd) -> runs cmd if target is outdated.
                 This is just a wrapper around target_outdated() which calls the given
                 command if target is outdated."""
                 if target_outdated(target,deps):
                     xsys(cmd)
             #----------------------------------------------------------------------------
             def unquote_ends(istr):
                 """Remove a single pair of quotes from the endpoints of a string."""
                 if not istr:
                     return istr
                 if (istr[0]=="'" and istr[-1]=="'") or \
                    (istr[0]=='"' and istr[-1]=='"'):
                     return istr[1:-1]
                 else:
                     return istr
             #----------------------------------------------------------------------------
             def process_cmdline(argv,names=[],defaults={},usage=''):
                 """ Process command-line options and arguments.
                 Arguments:
                 - argv: list of arguments, typically sys.argv.
                 - names: list of option names. See DPyGetOpt docs for details on options
                 syntax.
                 - defaults: dict of default values.
                 - usage: optional usage notice to print if a wrong argument is passed.
                 Return a dict of options and a list of free arguments."""
                 getopt = DPyGetOpt.DPyGetOpt()
                 getopt.setIgnoreCase(0)
                 getopt.parseConfiguration(names)
                 try:
                     getopt.processArguments(argv)
                 except DPyGetOpt.ArgumentError, exc:
                     print usage
                     warn('"%s"' % exc,level=4)
                 defaults.update(getopt.optionValues)
                 args = getopt.freeValues
                 return defaults,args
             #----------------------------------------------------------------------------
             def optstr2types(ostr):
                 """Convert a string of option names to a dict of type mappings.
                 optstr2types(str) -> {None:'string_opts',int:'int_opts',float:'float_opts'}
                 This is used to get the types of all the options in a string formatted
                 with the conventions of DPyGetOpt. The 'type' None is used for options
                 which are strings (they need no further conversion). This function's main
                 use is to get a typemap for use with read_dict().
                 """
                 typeconv = {None:'',int:'',float:''}
                 typemap = {'s':None,'i':int,'f':float}
                 opt_re = re.compile(r'([\w]*)([^:=]*:?=?)([sif]?)')
                 for w in ostr.split():
                     oname,alias,otype = opt_re.match(w).groups()
                     if otype == '' or alias == '!':   # simple switches are integers too
                         otype = 'i'
                     typeconv[typemap[otype]] += oname + ' '
                 return typeconv
             #----------------------------------------------------------------------------
             def read_dict(filename,type_conv=None,**opt):
                 """Read a dictionary of key=value pairs from an input file, optionally
                 performing conversions on the resulting values.
                 read_dict(filename,type_conv,**opt) -> dict
                 Only one value per line is accepted, the format should be
                  # optional comments are ignored
                  key value\n
                 Args:
                   - type_conv: A dictionary specifying which keys need to be converted to
                   which types. By default all keys are read as strings. This dictionary
                   should have as its keys valid conversion functions for strings
                   (int,long,float,complex, or your own).  The value for each key
                   (converter) should be a whitespace separated string containing the names
                   of all the entries in the file to be converted using that function. For
                   keys to be left alone, use None as the conversion function (only needed
                   with purge=1, see below).
                   - opt: dictionary with extra options as below (default in parens)
                     purge(0): if set to 1, all keys *not* listed in type_conv are purged out
                     of the dictionary to be returned. If purge is going to be used, the
                     set of keys to be left as strings also has to be explicitly specified
                     using the (non-existent) conversion function None.
                     fs(None): field separator. This is the key/value separator to be used
                     when parsing the file. The None default means any whitespace [behavior
                     of string.split()].
                     strip(0): if 1, strip string values of leading/trailinig whitespace.
                     warn(1): warning level if requested keys are not found in file.
                       - 0: silently ignore.
                       - 1: inform but proceed.
                       - 2: raise KeyError exception.
                     no_empty(0): if 1, remove keys with whitespace strings as a value.
                     unique([]): list of keys (or space separated string) which can't be
                     repeated. If one such key is found in the file, each new instance
                     overwrites the previous one. For keys not listed here, the behavior is
                     to make a list of all appearances.
                 Example:
                 If the input file test.ini has:
                   i 3
                   x 4.5
                   y 5.5
                   s hi ho
                 Then:
                 >>> type_conv={int:'i',float:'x',None:'s'}
                 >>> read_dict('test.ini')
                 {'i': '3', 's': 'hi ho', 'x': '4.5', 'y': '5.5'}
                 >>> read_dict('test.ini',type_conv)
                 {'i': 3, 's': 'hi ho', 'x': 4.5, 'y': '5.5'}
                 >>> read_dict('test.ini',type_conv,purge=1)
                 {'i': 3, 's': 'hi ho', 'x': 4.5}
                 """
                 # starting config
                 opt.setdefault('purge',0)
                 opt.setdefault('fs',None)  # field sep defaults to any whitespace
                 opt.setdefault('strip',0)
                 opt.setdefault('warn',1)
                 opt.setdefault('no_empty',0)
                 opt.setdefault('unique','')
                 if type(opt['unique']) in StringTypes:
                     unique_keys = qw(opt['unique'])
                 elif type(opt['unique']) in (types.TupleType,types.ListType):
                     unique_keys = opt['unique']
                 else:
                     raise ValueError, 'Unique keys must be given as a string, List or Tuple'
                 dict = {}
                 # first read in table of values as strings
                 file = open(filename,'r')
                 for line in file.readlines():
                     line = line.strip()
                     if len(line) and line[0]=='#': continue
                     if len(line)>0:
                         lsplit = line.split(opt['fs'],1)
                         try:
                             key,val = lsplit
                         except ValueError:
                             key,val = lsplit[0],''
                         key = key.strip()
                         if opt['strip']: val = val.strip()
                         if val == "''" or val == '""': val = ''
                         if opt['no_empty'] and (val=='' or val.isspace()):
                             continue
                         # if a key is found more than once in the file, build a list
                         # unless it's in the 'unique' list. In that case, last found in file
                         # takes precedence. User beware.
                         try:
                             if dict[key] and key in unique_keys:
                                 dict[key] = val
                             elif type(dict[key]) is types.ListType:
                                 dict[key].append(val)
                             else:
                                 dict[key] = [dict[key],val]
                         except KeyError:
                             dict[key] = val
                 # purge if requested
                 if opt['purge']:
                     accepted_keys = qwflat(type_conv.values())
                     for key in dict.keys():
                         if key in accepted_keys: continue
                         del(dict[key])
                 # now convert if requested
                 if type_conv==None: return dict
                 conversions = type_conv.keys()
                 try: conversions.remove(None)
                 except: pass
                 for convert in conversions:
                     for val in qw(type_conv[convert]):
                         try:
                             dict[val] = convert(dict[val])
                         except KeyError,e:
                             if opt['warn'] == 0:
                                 pass
                             elif opt['warn'] == 1:
                                 print >>sys.stderr, 'Warning: key',val,\
                                       'not found in file',filename
                             elif opt['warn'] == 2:
                                 raise KeyError,e
                             else:
                                 raise ValueError,'Warning level must be 0,1 or 2'
                 return dict
             #----------------------------------------------------------------------------
             def flag_calls(func):
                 """Wrap a function to detect and flag when it gets called.
                 This is a decorator which takes a function and wraps it in a function with
                 a 'called' attribute. wrapper.called is initialized to False.
                 The wrapper.called attribute is set to False right before each call to the
                 wrapped function, so if the call fails it remains False.  After the call
                 completes, wrapper.called is set to True and the output is returned.
                 Testing for truth in wrapper.called allows you to determine if a call to
                 func() was attempted and succeeded."""
                 def wrapper(*args,**kw):
                     wrapper.called = False
                     out = func(*args,**kw)
                     wrapper.called = True
                     return out
                 wrapper.called = False
                 wrapper.__doc__ = func.__doc__
                 return wrapper
             #----------------------------------------------------------------------------
             def dhook_wrap(func,*a,**k):
                 """Wrap a function call in a sys.displayhook controller.
                 Returns a wrapper around func which calls func, with all its arguments and
                 keywords unmodified, using the default sys.displayhook.  Since IPython
                 modifies sys.displayhook, it breaks the behavior of certain systems that
                 rely on the default behavior, notably doctest.
                 """
                 def f(*a,**k):
                     dhook_s = sys.displayhook
                     sys.displayhook = sys.__displayhook__
                     try:
                         out = func(*a,**k)
                     finally:
                         sys.displayhook = dhook_s
                     return out
                 f.__doc__ = func.__doc__
                 return f
             #----------------------------------------------------------------------------
             def doctest_reload():
                 """Properly reload doctest to reuse it interactively.
                 This routine:
                   - reloads doctest
                   - resets its global 'master' attribute to None, so that multiple uses of
                   the module interactively don't produce cumulative reports.
                   - Monkeypatches its core test runner method to protect it from IPython's
                   modified displayhook.  Doctest expects the default displayhook behavior
                   deep down, so our modification breaks it completely.  For this reason, a
                   hard monkeypatch seems like a reasonable solution rather than asking
                   users to manually use a different doctest runner when under IPython."""
                 import doctest
                 reload(doctest)
                 doctest.master=None
                 try:
                     doctest.DocTestRunner
                 except AttributeError:
                     # This is only for python 2.3 compatibility, remove once we move to
                     # 2.4 only.
                     pass
                 else:
                     doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
             #----------------------------------------------------------------------------
             class HomeDirError(Error):
                 pass
             def get_home_dir():
                 """Return the closest possible equivalent to a 'home' directory.
                 We first try $HOME.  Absent that, on NT it's $HOMEDRIVE\$HOMEPATH.
                 Currently only Posix and NT are implemented, a HomeDirError exception is
                 raised for all other OSes. """
                 isdir = os.path.isdir
                 env = os.environ
                 # first, check py2exe distribution root directory for _ipython.
                 # This overrides all. Normally does not exist.
                 if '\\library.zip\\' in IPython.__file__.lower():
                     root, rest = IPython.__file__.lower().split('library.zip')
                     if isdir(root + '_ipython'):
                         os.environ["IPYKITROOT"] = root.rstrip('\\')
                         return root
                 try:
                     homedir = env['HOME']
                     if not isdir(homedir):
                         # in case a user stuck some string which does NOT resolve to a
                         # valid path, it's as good as if we hadn't foud it
                         raise KeyError
                     return homedir
                 except KeyError:
                     if os.name == 'posix':
                         raise HomeDirError,'undefined $HOME, IPython can not proceed.'
                     elif os.name == 'nt':
                         # For some strange reason, win9x returns 'nt' for os.name.
                         try:
                             homedir = os.path.join(env['HOMEDRIVE'],env['HOMEPATH'])
                             if not isdir(homedir):
                                 homedir = os.path.join(env['USERPROFILE'])
                                 if not isdir(homedir):
                                     raise HomeDirError
                             return homedir
                         except:
                             try:
                                 # Use the registry to get the 'My Documents' folder.
                                 import _winreg as wreg
                                 key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
                                                    "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
                                 homedir = wreg.QueryValueEx(key,'Personal')[0]
                                 key.Close()
                                 if not isdir(homedir):
                                     e = ('Invalid "Personal" folder registry key '
                                          'typically "My Documents".\n'
                                          'Value: %s\n'
                                          'This is not a valid directory on your system.' %
                                          homedir)
                                     raise HomeDirError(e)
                                 return homedir
                             except HomeDirError:
                                 raise
                             except:
                                 return 'C:\\'
                     elif os.name == 'dos':
                         # Desperate, may do absurd things in classic MacOS. May work under DOS.
                         return 'C:\\'
                     else:
                         raise HomeDirError,'support for your operating system not implemented.'
             #****************************************************************************
             # strings and text
             class LSString(str):
                 """String derivative with a special access attributes.
                 These are normal strings, but with the special attributes:
                     .l (or .list) : value as list (split on newlines).
                     .n (or .nlstr): original value (the string itself).
                     .s (or .spstr): value as whitespace-separated string.
                     .p (or .paths): list of path objects
                 Any values which require transformations are computed only once and
                 cached.
                 Such strings are very useful to efficiently interact with the shell, which
                 typically only understands whitespace-separated options for commands."""
                 def get_list(self):
                     try:
                         return self.__list
                     except AttributeError:
                         self.__list = self.split('\n')
                         return self.__list
                 l = list = property(get_list)
                 def get_spstr(self):
                     try:
                         return self.__spstr
                     except AttributeError:
                         self.__spstr = self.replace('\n',' ')
                         return self.__spstr
                 s = spstr = property(get_spstr)
                 def get_nlstr(self):
                     return self
                 n = nlstr = property(get_nlstr)
                 def get_paths(self):
                     try:
                         return self.__paths
                     except AttributeError:
                         self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
                         return self.__paths
                 p = paths = property(get_paths)
             def print_lsstring(arg):
                 """ Prettier (non-repr-like) and more informative printer for LSString """
                 print "LSString (.p, .n, .l, .s available). Value:"
                 print arg
             print_lsstring = result_display.when_type(LSString)(print_lsstring)
             #----------------------------------------------------------------------------
             class SList(list):
                 """List derivative with a special access attributes.
                 These are normal lists, but with the special attributes:
                     .l (or .list) : value as list (the list itself).
                     .n (or .nlstr): value as a string, joined on newlines.
                     .s (or .spstr): value as a string, joined on spaces.
                     .p (or .paths): list of path objects
                 Any values which require transformations are computed only once and
                 cached."""
                 def get_list(self):
                     return self
                 l = list = property(get_list)
                 def get_spstr(self):
                     try:
                         return self.__spstr
                     except AttributeError:
                         self.__spstr = ' '.join(self)
                         return self.__spstr
                 s = spstr = property(get_spstr)
                 def get_nlstr(self):
                     try:
                         return self.__nlstr
                     except AttributeError:
                         self.__nlstr = '\n'.join(self)
                         return self.__nlstr
                 n = nlstr = property(get_nlstr)
                 def get_paths(self):
                     try:
                         return self.__paths
                     except AttributeError:
                         self.__paths = [path(p) for p in self if os.path.exists(p)]
                         return self.__paths
                 p = paths = property(get_paths)
                 def grep(self, pattern, prune = False):
                     """ Return all strings matching 'pattern' (a regex or callable)
                     This is case-insensitive. If prune is true, return all items
                     NOT matching the pattern.
                     Examples::
                         a.grep( lambda x: x.startswith('C') )
                         a.grep('Cha.*log', prune=1)
                     """
                     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)])
                     else:
                         return SList([el for el in self if not pred(el)])
                 def fields(self, *fields):
                     """ Collect whitespace-separated fields from string list
                     Allows quick awk-like usage of string lists.
                     Example data (in var a, created by 'a = !ls -l')::
                         -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
                         drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython
                     a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
                     a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
                     (note the joining by space).
                     IndexErrors are ignored.
                     Without args, fields() just split()'s the strings.
                     """
                     if len(fields) == 0:
                         return [el.split() for el in self]
                     res = SList()
                     for el in [f.split() for f in self]:
                         lineparts = []
                         for fd in fields:
                             try:
                                 lineparts.append(el[fd])
                             except IndexError:
                                 pass
                         if lineparts:
                             res.append(" ".join(lineparts))
                     return res
             def print_slist(arg):
                 """ Prettier (non-repr-like) and more informative printer for SList """
                 print "SList (.p, .n, .l, .s, .grep(), .fields() available). Value:"
                 nlprint(arg)
             print_slist = result_display.when_type(SList)(print_slist)
             #----------------------------------------------------------------------------
             def esc_quotes(strng):
                 """Return the input string with single and double quotes escaped out"""
                 return strng.replace('"','\\"').replace("'","\\'")
             #----------------------------------------------------------------------------
             def make_quoted_expr(s):
                 """Return string s in appropriate quotes, using raw string if possible.
                 Effectively this turns string: cd \ao\ao\
                 to: r"cd \ao\ao\_"[:-1]
                 Note the use of raw string and padding at the end to allow trailing backslash.
                 """
                 tail = ''
                 tailpadding = ''
                 raw  = ''
                 if "\\" in s:
                     raw = 'r'
                     if s.endswith('\\'):
                         tail = '[:-1]'
                         tailpadding = '_'
                 if '"' not in s:
                     quote = '"'
                 elif "'" not in s:
                     quote = "'"
                 elif '"""' not in s and not s.endswith('"'):
                     quote = '"""'
                 elif "'''" not in s and not s.endswith("'"):
                     quote = "'''"
                 else:
                     # give up, backslash-escaped string will do
                     return '"%s"' % esc_quotes(s)
                 res = raw + quote + s + tailpadding + quote + tail
                 return res
             #----------------------------------------------------------------------------
             def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
                 """Take multiple lines of input.
                 A list with each line of input as a separate element is returned when a
                 termination string is entered (defaults to a single '.'). Input can also
                 terminate via EOF (^D in Unix, ^Z-RET in Windows).
                 Lines of input which end in \\ are joined into single entries (and a
                 secondary continuation prompt is issued as long as the user terminates
                 lines with \\). This allows entering very long strings which are still
                 meant to be treated as single entities.
                 """
                 try:
                     if header:
                         header += '\n'
                     lines = [raw_input(header + ps1)]
                 except EOFError:
                     return []
                 terminate = [terminate_str]
                 try:
                     while lines[-1:] != terminate:
                         new_line = raw_input(ps1)
                         while new_line.endswith('\\'):
                             new_line = new_line[:-1] + raw_input(ps2)
                         lines.append(new_line)
                     return lines[:-1]  # don't return the termination command
                 except EOFError:
                     print
                     return lines
             #----------------------------------------------------------------------------
             def raw_input_ext(prompt='',  ps2='... '):
                 """Similar to raw_input(), but accepts extended lines if input ends with \\."""
                 line = raw_input(prompt)
                 while line.endswith('\\'):
                     line = line[:-1] + raw_input(ps2)
                 return line
             #----------------------------------------------------------------------------
             def ask_yes_no(prompt,default=None):
                 """Asks a question and returns a boolean (y/n) answer.
                 If default is given (one of 'y','n'), it is used if the user input is
                 empty. Otherwise the question is repeated until an answer is given.
                 An EOF is treated as the default answer.  If there is no default, an
                 exception is raised to prevent infinite loops.
                 Valid answers are: y/yes/n/no (match is not case sensitive)."""
                 answers = {'y':True,'n':False,'yes':True,'no':False}
                 ans = None
                 while ans not in answers.keys():
                     try:
                         ans = raw_input(prompt+' ').lower()
                         if not ans:  # response was an empty string
                             ans = default
                     except KeyboardInterrupt:
                         pass
                     except EOFError:
                         if default in answers.keys():
                             ans = default
                             print
                         else:
                             raise
                 return answers[ans]
             #----------------------------------------------------------------------------
             def marquee(txt='',width=78,mark='*'):
                 """Return the input string centered in a 'marquee'."""
                 if not txt:
                     return (mark*width)[:width]
                 nmark = (width-len(txt)-2)/len(mark)/2
                 if nmark < 0: nmark =0
                 marks = mark*nmark
                 return '%s %s %s' % (marks,txt,marks)
             #----------------------------------------------------------------------------
             class EvalDict:
                 """
                 Emulate a dict which evaluates its contents in the caller's frame.
                 Usage:
                 >>>number = 19
                 >>>text = "python"
                 >>>print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
                 """
                 # This version is due to sismex01@hebmex.com on c.l.py, and is basically a
                 # modified (shorter) version of:
                 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
                 # Skip Montanaro (skip@pobox.com).
                 def __getitem__(self, name):
                     frame = sys._getframe(1)
                     return eval(name, frame.f_globals, frame.f_locals)
             EvalString = EvalDict  # for backwards compatibility
             #----------------------------------------------------------------------------
             def qw(words,flat=0,sep=None,maxsplit=-1):
                 """Similar to Perl's qw() operator, but with some more options.
                 qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
                 words can also be a list itself, and with flat=1, the output will be
                 recursively flattened. Examples:
                 >>> qw('1 2')
                 ['1', '2']
                 >>> qw(['a b','1 2',['m n','p q']])
                 [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
                 >>> qw(['a b','1 2',['m n','p q']],flat=1)
                 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']    """
                 if type(words) in StringTypes:
                     return [word.strip() for word in words.split(sep,maxsplit)
                             if word and not word.isspace() ]
                 if flat:
                     return flatten(map(qw,words,[1]*len(words)))
                 return map(qw,words)
             #----------------------------------------------------------------------------
             def qwflat(words,sep=None,maxsplit=-1):
                 """Calls qw(words) in flat mode. It's just a convenient shorthand."""
                 return qw(words,1,sep,maxsplit)
             #----------------------------------------------------------------------------
             def qw_lol(indata):
                 """qw_lol('a b') -> [['a','b']],
                 otherwise it's just a call to qw().
                 We need this to make sure the modules_some keys *always* end up as a
                 list of lists."""
                 if type(indata) in StringTypes:
                     return [qw(indata)]
                 else:
                     return qw(indata)
             #-----------------------------------------------------------------------------
             def list_strings(arg):
                 """Always return a list of strings, given a string or list of strings
                 as input."""
                 if type(arg) in StringTypes: return [arg]
                 else: return arg
             #----------------------------------------------------------------------------
             def grep(pat,list,case=1):
                 """Simple minded grep-like function.
                 grep(pat,list) returns occurrences of pat in list, None on failure.
                 It only does simple string matching, with no support for regexps. Use the
                 option case=0 for case-insensitive matching."""
                 # This is pretty crude. At least it should implement copying only references
                 # to the original data in case it's big. Now it copies the data for output.
                 out=[]
                 if case:
                     for term in list:
                         if term.find(pat)>-1: out.append(term)
                 else:
                     lpat=pat.lower()
                     for term in list:
                         if term.lower().find(lpat)>-1: out.append(term)
                 if len(out): return out
                 else: return None
             #----------------------------------------------------------------------------
             def dgrep(pat,*opts):
                 """Return grep() on dir()+dir(__builtins__).
                 A very common use of grep() when working interactively."""
                 return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
             #----------------------------------------------------------------------------
             def idgrep(pat):
                 """Case-insensitive dgrep()"""
                 return dgrep(pat,0)
             #----------------------------------------------------------------------------
             def igrep(pat,list):
                 """Synonym for case-insensitive grep."""
                 return grep(pat,list,case=0)
             #----------------------------------------------------------------------------
             def indent(str,nspaces=4,ntabs=0):
                 """Indent a string a given number of spaces or tabstops.
                 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
                 """
                 if str is None:
                     return
                 ind = '\t'*ntabs+' '*nspaces
                 outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
                 if outstr.endswith(os.linesep+ind):
                     return outstr[:-len(ind)]
                 else:
                     return outstr
             #-----------------------------------------------------------------------------
             def native_line_ends(filename,backup=1):
                 """Convert (in-place) a file to line-ends native to the current OS.
                 If the optional backup argument is given as false, no backup of the
                 original file is left.  """
                 backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
                 bak_filename = filename + backup_suffixes[os.name]
                 original = open(filename).read()
                 shutil.copy2(filename,bak_filename)
                 try:
                     new = open(filename,'wb')
                     new.write(os.linesep.join(original.splitlines()))
                     new.write(os.linesep) # ALWAYS put an eol at the end of the file
                     new.close()
                 except:
                     os.rename(bak_filename,filename)
                 if not backup:
                     try:
                         os.remove(bak_filename)
                     except:
                         pass
             #----------------------------------------------------------------------------
             def get_pager_cmd(pager_cmd = None):
                 """Return a pager command.
                 Makes some attempts at finding an OS-correct one."""
                 if os.name == 'posix':
                     default_pager_cmd = 'less -r'  # -r for color control sequences
                 elif os.name in ['nt','dos']:
                     default_pager_cmd = 'type'
                 if pager_cmd is None:
                     try:
                         pager_cmd = os.environ['PAGER']
                     except:
                         pager_cmd = default_pager_cmd
                 return pager_cmd
             #-----------------------------------------------------------------------------
             def get_pager_start(pager,start):
                 """Return the string for paging files with an offset.
                 This is the '+N' argument which less and more (under Unix) accept.
                 """
                 if pager in ['less','more']:
                     if start:
                         start_string = '+' + str(start)
                     else:
                         start_string = ''
                 else:
                     start_string = ''
                 return start_string
             #----------------------------------------------------------------------------
             # (X)emacs on W32 doesn't like to be bypassed with msvcrt.getch()
             if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
                 import msvcrt
                 def page_more():
                     """ Smart pausing between pages
                     @return:    True if need print more lines, False if quit
                     """
                     Term.cout.write('---Return to continue, q to quit--- ')
                     ans = msvcrt.getch()
                     if ans in ("q", "Q"):
                         result = False
                     else:
                         result = True
                     Term.cout.write("\b"*37 + " "*37 + "\b"*37)
                     return result
             else:
                 def page_more():
                     ans = raw_input('---Return to continue, q to quit--- ')
                     if ans.lower().startswith('q'):
                         return False
                     else:
                         return True
             esc_re = re.compile(r"(\x1b[^m]+m)")
             def page_dumb(strng,start=0,screen_lines=25):
                 """Very dumb 'pager' in Python, for when nothing else works.
                 Only moves forward, same interface as page(), except for pager_cmd and
                 mode."""
                 out_ln  = strng.splitlines()[start:]
                 screens = chop(out_ln,screen_lines-1)
                 if len(screens) == 1:
                     print >>Term.cout, os.linesep.join(screens[0])
                 else:
                     last_escape = ""
                     for scr in screens[0:-1]:
                         hunk = os.linesep.join(scr)
                         print >>Term.cout, last_escape + hunk
                         if not page_more():
                             return
                         esc_list = esc_re.findall(hunk)
                         if len(esc_list) > 0:
                             last_escape = esc_list[-1]
                     print >>Term.cout, last_escape + os.linesep.join(screens[-1])
             #----------------------------------------------------------------------------
             def page(strng,start=0,screen_lines=0,pager_cmd = None):
                 """Print a string, piping through a pager after a certain length.
                 The screen_lines parameter specifies the number of *usable* lines of your
                 terminal screen (total lines minus lines you need to reserve to show other
                 information).
                 If you set screen_lines to a number <=0, page() will try to auto-determine
                 your screen size and will only use up to (screen_size+screen_lines) for
                 printing, paging after that. That is, if you want auto-detection but need
                 to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
                 auto-detection without any lines reserved simply use screen_lines = 0.
                 If a string won't fit in the allowed lines, it is sent through the
                 specified pager command. If none given, look for PAGER in the environment,
                 and ultimately default to less.
                 If no system pager works, the string is sent through a 'dumb pager'
                 written in python, very simplistic.
                 """
                 # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
                 TERM = os.environ.get('TERM','dumb')
                 if TERM in ['dumb','emacs'] and os.name != 'nt':
                     print strng
                     return
                 # chop off the topmost part of the string we don't want to see
                 str_lines = strng.split(os.linesep)[start:]
                 str_toprint = os.linesep.join(str_lines)
                 num_newlines = len(str_lines)
                 len_str = len(str_toprint)
                 # Dumb heuristics to guesstimate number of on-screen lines the string
                 # takes.  Very basic, but good enough for docstrings in reasonable
                 # terminals. If someone later feels like refining it, it's not hard.
                 numlines = max(num_newlines,int(len_str/80)+1)
                 if os.name == "nt":
                     screen_lines_def = get_console_size(defaulty=25)[1]
                 else:
                     screen_lines_def = 25 # default value if we can't auto-determine
                 # 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
                     else:
                         # curses causes problems on many terminals other than xterm.
                         use_curses = 0
                     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
                     else:
                             screen_lines += screen_lines_def
                 #print 'numlines',numlines,'screenlines',screen_lines  # dbg
                 if numlines <= screen_lines :
                     #print '*** normal print'  # dbg
                     print >>Term.cout, str_toprint
                 else:
                     # Try to open pager and default to internal one if that fails.
                     # All failure modes are tagged as 'retval=1', to match the return
                     # value of a failed system command.  If any intermediate attempt
                     # sets retval to 1, at the end we resort to our own page_dumb() pager.
                     pager_cmd = get_pager_cmd(pager_cmd)
                     pager_cmd += ' ' + get_pager_start(pager_cmd,start)
                     if os.name == 'nt':
                         if pager_cmd.startswith('type'):
                             # The default WinXP 'type' command is failing on complex strings.
                             retval = 1
                         else:
                             tmpname = tempfile.mktemp('.txt')
                             tmpfile = file(tmpname,'wt')
                             tmpfile.write(strng)
                             tmpfile.close()
                             cmd = "%s < %s" % (pager_cmd,tmpname)
                             if os.system(cmd):
                               retval = 1
                             else:
                               retval = None
                             os.remove(tmpname)
                     else:
                         try:
                             retval = None
                             # if I use popen4, things hang. No idea why.
                             #pager,shell_out = os.popen4(pager_cmd)
                             pager = os.popen(pager_cmd,'w')
                             pager.write(strng)
                             pager.close()
                             retval = pager.close()  # success returns None
                         except IOError,msg:  # broken pipe when user quits
                             if msg.args == (32,'Broken pipe'):
                                 retval = None
                             else:
                                 retval = 1
                         except OSError:
                             # Other strange problems, sometimes seen in Win2k/cygwin
                             retval = 1
                     if retval is not None:
                         page_dumb(strng,screen_lines=screen_lines)
             #----------------------------------------------------------------------------
             def page_file(fname,start = 0, pager_cmd = None):
                 """Page a file, using an optional pager command and starting line.
                 """
                 pager_cmd = get_pager_cmd(pager_cmd)
                 pager_cmd += ' ' + get_pager_start(pager_cmd,start)
                 try:
                     if os.environ['TERM'] in ['emacs','dumb']:
                         raise EnvironmentError
                     xsys(pager_cmd + ' ' + fname)
                 except:
                     try:
                         if start > 0:
                             start -= 1
                         page(open(fname).read(),start)
                     except:
                         print 'Unable to show file',`fname`
             #----------------------------------------------------------------------------
             def snip_print(str,width = 75,print_full = 0,header = ''):
                 """Print a string snipping the midsection to fit in width.
                 print_full: mode control:
                   - 0: only snip long strings
                   - 1: send to page() directly.
                   - 2: snip long strings and ask for full length viewing with page()
                 Return 1 if snipping was necessary, 0 otherwise."""
                 if print_full == 1:
                     page(header+str)
                     return 0
                 print header,
                 if len(str) < width:
                     print str
                     snip = 0
                 else:
                     whalf = int((width -5)/2)
                     print str[:whalf] + ' <...> ' + str[-whalf:]
                     snip = 1
                 if snip and print_full == 2:
                     if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
                         page(str)
                 return snip
             #****************************************************************************
             # lists, dicts and structures
             def belong(candidates,checklist):
                 """Check whether a list of items appear in a given list of options.
                 Returns a list of 1 and 0, one for each candidate given."""
                 return [x in checklist for x in candidates]
             #----------------------------------------------------------------------------
             def uniq_stable(elems):
                 """uniq_stable(elems) -> list
                 Return from an iterable, a list of all the unique elements in the input,
                 but maintaining the order in which they first appear.
                 A naive solution to this problem which just makes a dictionary with the
                 elements as keys fails to respect the stability condition, since
                 dictionaries are unsorted by nature.
                 Note: All elements in the input must be valid dictionary keys for this
                 routine to work, as it internally uses a dictionary for efficiency
                 reasons."""
                 unique = []
                 unique_dict = {}
                 for nn in elems:
                     if nn not in unique_dict:
                         unique.append(nn)
                         unique_dict[nn] = None
                 return unique
             #----------------------------------------------------------------------------
             class NLprinter:
                 """Print an arbitrarily nested list, indicating index numbers.
                 An instance of this class called nlprint is available and callable as a
                 function.
                 nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
                 and using 'sep' to separate the index from the value. """
                 def __init__(self):
                     self.depth = 0
                 def __call__(self,lst,pos='',**kw):
                     """Prints the nested list numbering levels."""
                     kw.setdefault('indent',' ')
                     kw.setdefault('sep',': ')
                     kw.setdefault('start',0)
                     kw.setdefault('stop',len(lst))
                     # we need to remove start and stop from kw so they don't propagate
                     # into a recursive call for a nested list.
                     start = kw['start']; del kw['start']
                     stop = kw['stop']; del kw['stop']
                     if self.depth == 0 and 'header' in kw.keys():
                         print kw['header']
                     for idx in range(start,stop):
                         elem = lst[idx]
                         if type(elem)==type([]):
                             self.depth += 1
                             self.__call__(elem,itpl('$pos$idx,'),**kw)
                             self.depth -= 1
                         else:
                             printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
             nlprint = NLprinter()
             #----------------------------------------------------------------------------
             def all_belong(candidates,checklist):
                 """Check whether a list of items ALL appear in a given list of options.
                 Returns a single 1 or 0 value."""
                 return 1-(0 in [x in checklist for x in candidates])
             #----------------------------------------------------------------------------
             def sort_compare(lst1,lst2,inplace = 1):
                 """Sort and compare two lists.
                 By default it does it in place, thus modifying the lists. Use inplace = 0
                 to avoid that (at the cost of temporary copy creation)."""
                 if not inplace:
                     lst1 = lst1[:]
                     lst2 = lst2[:]
                 lst1.sort(); lst2.sort()
                 return lst1 == lst2
             #----------------------------------------------------------------------------
             def mkdict(**kwargs):
                 """Return a dict from a keyword list.
                 It's just syntactic sugar for making ditcionary creation more convenient:
                 # the standard way
                 >>>data = { 'red' : 1, 'green' : 2, 'blue' : 3 }
                 # a cleaner way
                 >>>data = dict(red=1, green=2, blue=3)
                 If you need more than this, look at the Struct() class."""
                 return kwargs
             #----------------------------------------------------------------------------
             def list2dict(lst):
                 """Takes a list of (key,value) pairs and turns it into a dict."""
                 dic = {}
                 for k,v in lst: dic[k] = v
                 return dic
             #----------------------------------------------------------------------------
             def list2dict2(lst,default=''):
                 """Takes a list and turns it into a dict.
                 Much slower than list2dict, but more versatile. This version can take
                 lists with sublists of arbitrary length (including sclars)."""
                 dic = {}
                 for elem in lst:
                     if type(elem) in (types.ListType,types.TupleType):
                         size = len(elem)
                         if  size == 0:
                             pass
                         elif size == 1:
                             dic[elem] = default
                         else:
                             k,v = elem[0], elem[1:]
                             if len(v) == 1: v = v[0]
                             dic[k] = v
                     else:
                         dic[elem] = default
                 return dic
             #----------------------------------------------------------------------------
             def flatten(seq):
                 """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
                 return [x for subseq in seq for x in subseq]
             #----------------------------------------------------------------------------
             def get_slice(seq,start=0,stop=None,step=1):
                 """Get a slice of a sequence with variable step. Specify start,stop,step."""
                 if stop == None:
                     stop = len(seq)
                 item = lambda i: seq[i]
                 return map(item,xrange(start,stop,step))
             #----------------------------------------------------------------------------
             def chop(seq,size):
                 """Chop a sequence into chunks of the given size."""
                 chunk = lambda i: seq[i:i+size]
                 return map(chunk,xrange(0,len(seq),size))
             #----------------------------------------------------------------------------
             # with is a keyword as of python 2.5, so this function is renamed to withobj
             # from its old 'with' name.
             def with_obj(object, **args):
                 """Set multiple attributes for an object, similar to Pascal's with.
                 Example:
                 with_obj(jim,
                          born = 1960,
                          haircolour = 'Brown',
                          eyecolour = 'Green')
                 Credit: Greg Ewing, in
                 http://mail.python.org/pipermail/python-list/2001-May/040703.html.
                 NOTE: up until IPython 0.7.2, this was called simply 'with', but 'with'
                 has become a keyword for Python 2.5, so we had to rename it."""
                 object.__dict__.update(args)
             #----------------------------------------------------------------------------
             def setattr_list(obj,alist,nspace = None):
                 """Set a list of attributes for an object taken from a namespace.
                 setattr_list(obj,alist,nspace) -> sets in obj all the attributes listed in
                 alist with their values taken from nspace, which must be a dict (something
                 like locals() will often do) If nspace isn't given, locals() of the
                 *caller* is used, so in most cases you can omit it.
                 Note that alist can be given as a string, which will be automatically
                 split into a list on whitespace. If given as a list, it must be a list of
                 *strings* (the variable names themselves), not of variables."""
                 # this grabs the local variables from the *previous* call frame -- that is
                 # the locals from the function that called setattr_list().
                 # - snipped from weave.inline()
                 if nspace is None:
                     call_frame = sys._getframe().f_back
                     nspace = call_frame.f_locals
                 if type(alist) in StringTypes:
                     alist = alist.split()
                 for attr in alist:
                     val = eval(attr,nspace)
                     setattr(obj,attr,val)
             #----------------------------------------------------------------------------
             def getattr_list(obj,alist,*args):
                 """getattr_list(obj,alist[, default]) -> attribute list.
                 Get a list of named attributes for an object. When a default argument is
                 given, it is returned when the attribute doesn't exist; without it, an
                 exception is raised in that case.
                 Note that alist can be given as a string, which will be automatically
                 split into a list on whitespace. If given as a list, it must be a list of
                 *strings* (the variable names themselves), not of variables."""
                 if type(alist) in StringTypes:
                     alist = alist.split()
                 if args:
                     if len(args)==1:
                         default = args[0]
                         return map(lambda attr: getattr(obj,attr,default),alist)
                     else:
                         raise ValueError,'getattr_list() takes only one optional argument'
                 else:
                     return map(lambda attr: getattr(obj,attr),alist)
             #----------------------------------------------------------------------------
             def map_method(method,object_list,*argseq,**kw):
                 """map_method(method,object_list,*args,**kw) -> list
                 Return a list of the results of applying the methods to the items of the
                 argument sequence(s).  If more than one sequence is given, the method is
                 called with an argument list consisting of the corresponding item of each
                 sequence. All sequences must be of the same length.
                 Keyword arguments are passed verbatim to all objects called.
                 This is Python code, so it's not nearly as fast as the builtin map()."""
                 out_list = []
                 idx = 0
                 for object in object_list:
                     try:
                         handler = getattr(object, method)
                     except AttributeError:
                         out_list.append(None)
                     else:
                         if argseq:
                             args = map(lambda lst:lst[idx],argseq)
                             #print 'ob',object,'hand',handler,'ar',args # dbg
                             out_list.append(handler(args,**kw))
                         else:
                             out_list.append(handler(**kw))
                     idx += 1
                 return out_list
             #----------------------------------------------------------------------------
             def get_class_members(cls):
                 ret = dir(cls)
                 if hasattr(cls,'__bases__'):
                     for base in cls.__bases__:
                         ret.extend(get_class_members(base))
                 return ret
             #----------------------------------------------------------------------------
             def dir2(obj):
                 """dir2(obj) -> list of strings
                 Extended version of the Python builtin dir(), which does a few extra
                 checks, and supports common objects with unusual internals that confuse
                 dir(), such as Traits and PyCrust.
                 This version is guaranteed to return only a list of true strings, whereas
                 dir() returns anything that objects inject into themselves, even if they
                 are later not really valid for attribute access (many extension libraries
                 have such bugs).
                 """
                 # Start building the attribute list via dir(), and then complete it
                 # with a few extra special-purpose calls.
                 words = dir(obj)
                 if hasattr(obj,'__class__'):
                     words.append('__class__')
                     words.extend(get_class_members(obj.__class__))
                 #if '__base__' in words: 1/0
                 # Some libraries (such as traits) may introduce duplicates, we want to
                 # track and clean this up if it happens
                 may_have_dupes = False
                 # this is the 'dir' function for objects with Enthought's traits
                 if hasattr(obj, 'trait_names'):
                     try:
                         words.extend(obj.trait_names())
                         may_have_dupes = True
                     except TypeError:
                         # This will happen if `obj` is a class and not an instance.
                         pass
                 # Support for PyCrust-style _getAttributeNames magic method.
                 if hasattr(obj, '_getAttributeNames'):
                     try:
                         words.extend(obj._getAttributeNames())
                         may_have_dupes = True
                     except TypeError:
                         # `obj` is a class and not an instance.  Ignore
                         # this error.
                         pass
                 if may_have_dupes:
                     # eliminate possible duplicates, as some traits may also
                     # appear as normal attributes in the dir() call.
                     words = list(set(words))
                     words.sort()
                 # filter out non-string attributes which may be stuffed by dir() calls
                 # and poor coding in third-party modules
                 return [w for w in words if isinstance(w, basestring)]
             #----------------------------------------------------------------------------
             def import_fail_info(mod_name,fns=None):
                 """Inform load failure for a module."""
                 if fns == None:
                     warn("Loading of %s failed.\n" % (mod_name,))
                 else:
                     warn("Loading of %s from %s failed.\n" % (fns,mod_name))
             #----------------------------------------------------------------------------
             # Proposed popitem() extension, written as a method
             class NotGiven: pass
             def popkey(dct,key,default=NotGiven):
                 """Return dct[key] and delete dct[key].
                 If default is given, return it if dct[key] doesn't exist, otherwise raise
                 KeyError.  """
                 try:
                     val = dct[key]
                 except KeyError:
                     if default is NotGiven:
                         raise
                     else:
                         return default
                 else:
                     del dct[key]
                     return val
             def wrap_deprecated(func, suggest = '<nothing>'):
                 def newFunc(*args, **kwargs):
                     warnings.warn("Call to deprecated function %s, use %s instead" %
                                   ( func.__name__, suggest),
                                   category=DeprecationWarning,
                                   stacklevel = 2)
                     return func(*args, **kwargs)
                 return newFunc
             #*************************** end of file <genutils.py> **********************

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages