Move ibrowse into a separate module.

IPython/Extensions/ibrowse.py

@@ -0,0 +1,1413 b''
+# -*- coding: iso-8859-1 -*-
+
+import curses
+
+import astyle, ipipe
+
+
+_ibrowse_help = """
+down
+Move the cursor to the next line.
+
+up
+Move the cursor to the previous line.
+
+pagedown
+Move the cursor down one page (minus overlap).
+
+pageup
+Move the cursor up one page (minus overlap).
+
+left
+Move the cursor left.
+
+right
+Move the cursor right.
+
+home
+Move the cursor to the first column.
+
+end
+Move the cursor to the last column.
+
+prevattr
+Move the cursor one attribute column to the left.
+
+nextattr
+Move the cursor one attribute column to the right.
+
+pick
+'Pick' the object under the cursor (i.e. the row the cursor is on). This
+leaves the browser and returns the picked object to the caller. (In IPython
+this object will be available as the '_' variable.)
+
+pickattr
+'Pick' the attribute under the cursor (i.e. the row/column the cursor is on).
+
+pickallattrs
+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.
+
+tooglemark
+Mark/unmark the object under the cursor. Marked objects have a '!' after the
+row number).
+
+pickmarked
+'Pick' marked objects. Marked objects will be returned as a list.
+
+pickmarkedattr
+'Pick' the attribute under the cursor from all marked objects (This returns a
+list).
+
+enterdefault
+Enter the object under the cursor. (what this mean depends on the object
+itself (i.e. how it implements the '__xiter__' method). This opens a new
+browser 'level'.
+
+enter
+Enter the object under the cursor. If the object provides different enter
+modes a menu of all modes will be presented; choose one and enter it (via the
+'enter' or 'enterdefault' command).
+
+enterattr
+Enter the attribute under the cursor.
+
+leave
+Leave the current browser level and go back to the previous one.
+
+detail
+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).
+
+detailattr
+Show a detail view of the attribute under the cursor.
+
+markrange
+Mark all objects from the last marked object before the current cursor
+position to the cursor position.
+
+sortattrasc
+Sort the objects (in ascending order) using the attribute under the cursor as
+the sort key.
+
+sortattrdesc
+Sort the objects (in descending order) using the attribute under the cursor as
+the sort key.
+
+goto
+Jump to a row. The row number can be entered at the bottom of the screen.
+
+find
+Search forward for a row. At the bottom of the screen the condition can be
+entered.
+
+findbackwards
+Search backward for a row. At the bottom of the screen the condition can be
+entered.
+
+help
+This screen.
+"""
+
+
+class UnassignedKeyError(Exception):
+    """
+    Exception that is used for reporting unassigned keys.
+    """
+
+
+class UnknownCommandError(Exception):
+    """
+    Exception that is used for reporting unknown command (this should never
+    happen).
+    """
+
+
+class CommandError(Exception):
+    """
+    Exception that is used for reporting that a command can't be executed.
+    """
+
+
+class _BrowserCachedItem(object):
+    # This is used internally by ``ibrowse`` to store a item together with its
+    # marked status.
+    __slots__ = ("item", "marked")
+
+    def __init__(self, item):
+        self.item = item
+        self.marked = False
+
+
+class _BrowserHelp(object):
+    style_header = astyle.Style.fromstr("red:blacK")
+    # This is used internally by ``ibrowse`` for displaying the help screen.
+    def __init__(self, browser):
+        self.browser = browser
+
+    def __xrepr__(self, mode):
+        yield (-1, True)
+        if mode == "header" or mode == "footer":
+            yield (astyle.style_default, "ibrowse help screen")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __xiter__(self, mode):
+        # Get reverse key mapping
+        allkeys = {}
+        for (key, cmd) in self.browser.keymap.iteritems():
+            allkeys.setdefault(cmd, []).append(key)
+
+        fields = ("key", "description")
+
+        for (i, command) in enumerate(_ibrowse_help.strip().split("\n\n")):
+            if i:
+                yield Fields(fields, key="", description="")
+
+            (name, description) = command.split("\n", 1)
+            keys = allkeys.get(name, [])
+            lines = textwrap.wrap(description, 60)
+
+            yield Fields(fields, description=astyle.Text((self.style_header, name)))
+            for i in xrange(max(len(keys), len(lines))):
+                try:
+                    key = self.browser.keylabel(keys[i])
+                except IndexError:
+                    key = ""
+                try:
+                    line = lines[i]
+                except IndexError:
+                    line = ""
+                yield Fields(fields, key=key, description=line)
+
+
+class _BrowserLevel(object):
+    # This is used internally to store the state (iterator, fetch items,
+    # position of cursor and screen, etc.) of one browser level
+    # An ``ibrowse`` object keeps multiple ``_BrowserLevel`` objects in
+    # a stack.
+    def __init__(self, browser, input, iterator, mainsizey, *attrs):
+        self.browser = browser
+        self.input = input
+        self.header = [x for x in ipipe.xrepr(input, "header") if not isinstance(x[0], int)]
+        # iterator for the input
+        self.iterator = iterator
+
+        # is the iterator exhausted?
+        self.exhausted = False
+
+        # attributes to be display (autodetected if empty)
+        self.attrs = attrs
+
+        # fetched items (+ marked flag)
+        self.items = ipipe.deque()
+
+        # Number of marked objects
+        self.marked = 0
+
+        # Vertical cursor position
+        self.cury = 0
+
+        # Horizontal cursor position
+        self.curx = 0
+
+        # Index of first data column
+        self.datastartx = 0
+
+        # Index of first data line
+        self.datastarty = 0
+
+        # height of the data display area
+        self.mainsizey = mainsizey
+
+        # width of the data display area (changes when scrolling)
+        self.mainsizex = 0
+
+        # Size of row number (changes when scrolling)
+        self.numbersizex = 0
+
+        # Attribute names to display (in this order)
+        self.displayattrs = []
+
+        # index and name of attribute under the cursor
+        self.displayattr = (None, ipipe._default)
+
+        # Maps attribute names to column widths
+        self.colwidths = {}
+
+        self.fetch(mainsizey)
+        self.calcdisplayattrs()
+        # formatted attributes for the items on screen
+        # (i.e. self.items[self.datastarty:self.datastarty+self.mainsizey])
+        self.displayrows = [self.getrow(i) for i in xrange(len(self.items))]
+        self.calcwidths()
+        self.calcdisplayattr()
+
+    def fetch(self, count):
+        # Try to fill ``self.items`` with at least ``count`` objects.
+        have = len(self.items)
+        while not self.exhausted and have < count:
+            try:
+                item = self.iterator.next()
+            except StopIteration:
+                self.exhausted = True
+                break
+            else:
+                have += 1
+                self.items.append(_BrowserCachedItem(item))
+
+    def calcdisplayattrs(self):
+        # Calculate which attributes are available from the objects that are
+        # currently visible on screen (and store it in ``self.displayattrs``)
+        attrnames = set()
+        # If the browser object specifies a fixed list of attributes,
+        # simply use it.
+        if self.attrs:
+            self.displayattrs = self.attrs
+        else:
+            self.displayattrs = []
+            endy = min(self.datastarty+self.mainsizey, len(self.items))
+            for i in xrange(self.datastarty, endy):
+                for attrname in ipipe.xattrs(self.items[i].item, "default"):
+                    if attrname not in attrnames:
+                        self.displayattrs.append(attrname)
+                        attrnames.add(attrname)
+
+    def getrow(self, i):
+        # Return a dictinary with the attributes for the object
+        # ``self.items[i]``. Attribute names are taken from
+        # ``self.displayattrs`` so ``calcdisplayattrs()`` must have been
+        # called before.
+        row = {}
+        item = self.items[i].item
+        for attrname in self.displayattrs:
+            try:
+                value = ipipe._getattr(item, attrname, ipipe._default)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                value = exc
+            # only store attribute if it exists (or we got an exception)
+            if value is not ipipe._default:
+                parts = []
+                totallength = 0
+                align = None
+                full = False
+                # Collect parts until we have enough
+                for part in ipipe.xrepr(value, "cell"):
+                    # part gives (alignment, stop)
+                    # instead of (style, text)
+                    if isinstance(part[0], int):
+                        # only consider the first occurence
+                        if align is None:
+                            align = part[0]
+                            full = part[1]
+                    else:
+                        parts.append(part)
+                        totallength += len(part[1])
+                        if totallength >= self.browser.maxattrlength and not full:
+                            parts.append((astyle.style_ellisis, "..."))
+                            totallength += 3
+                            break
+                # remember alignment, length and colored parts
+                row[attrname] = (align, totallength, parts)
+        return row
+
+    def calcwidths(self):
+        # Recalculate the displayed fields and their width.
+        # ``calcdisplayattrs()'' must have been called and the cache
+        # for attributes of the objects on screen (``self.displayrows``)
+        # must have been filled. This returns a dictionary mapping
+        # colmn names to width.
+        self.colwidths = {}
+        for row in self.displayrows:
+            for attrname in self.displayattrs:
+                try:
+                    length = row[attrname][1]
+                except KeyError:
+                    length = 0
+                # always add attribute to colwidths, even if it doesn't exist
+                if attrname not in self.colwidths:
+                    self.colwidths[attrname] = len(ipipe._attrname(attrname))
+                newwidth = max(self.colwidths[attrname], length)
+                self.colwidths[attrname] = newwidth
+
+        # How many characters do we need to paint the item number?
+        self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
+        # How must space have we got to display data?
+        self.mainsizex = self.browser.scrsizex-self.numbersizex-3
+        # width of all columns
+        self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
+
+    def calcdisplayattr(self):
+        # Find out on which attribute the cursor is on and store this
+        # information in ``self.displayattr``.
+        pos = 0
+        for (i, attrname) in enumerate(self.displayattrs):
+            if pos+self.colwidths[attrname] >= self.curx:
+                self.displayattr = (i, attrname)
+                break
+            pos += self.colwidths[attrname]+1
+        else:
+            self.displayattr = (None, ipipe._default)
+
+    def moveto(self, x, y, refresh=False):
+        # Move the cursor to the position ``(x,y)`` (in data coordinates,
+        # not in screen coordinates). If ``refresh`` is true, all cached
+        # values will be recalculated (e.g. because the list has been
+        # resorted, so screen positions etc. are no longer valid).
+        olddatastarty = self.datastarty
+        oldx = self.curx
+        oldy = self.cury
+        x = int(x+0.5)
+        y = int(y+0.5)
+        newx = x # remember where we wanted to move
+        newy = y # remember where we wanted to move
+
+        scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
+        scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
+
+        # Make sure that the cursor didn't leave the main area vertically
+        if y < 0:
+            y = 0
+        self.fetch(y+scrollbordery+1) # try to get more items
+        if y >= len(self.items):
+            y = max(0, len(self.items)-1)
+
+        # Make sure that the cursor stays on screen vertically
+        if y < self.datastarty+scrollbordery:
+            self.datastarty = max(0, y-scrollbordery)
+        elif y >= self.datastarty+self.mainsizey-scrollbordery:
+            self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
+                                         len(self.items)-self.mainsizey))
+
+        if refresh: # Do we need to refresh the complete display?
+            self.calcdisplayattrs()
+            endy = min(self.datastarty+self.mainsizey, len(self.items))
+            self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
+            self.calcwidths()
+        # Did we scroll vertically => update displayrows
+        # and various other attributes
+        elif self.datastarty != olddatastarty:
+            # Recalculate which attributes we have to display
+            olddisplayattrs = self.displayattrs
+            self.calcdisplayattrs()
+            # If there are new attributes, recreate the cache
+            if self.displayattrs != olddisplayattrs:
+                endy = min(self.datastarty+self.mainsizey, len(self.items))
+                self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
+            elif self.datastarty<olddatastarty: # we did scroll up
+                # drop rows from the end
+                del self.displayrows[self.datastarty-olddatastarty:]
+                # fetch new items
+                for i in xrange(olddatastarty-1,
+                                self.datastarty-1, -1):
+                    try:
+                        row = self.getrow(i)
+                    except IndexError:
+                        # we didn't have enough objects to fill the screen
+                        break
+                    self.displayrows.insert(0, row)
+            else: # we did scroll down
+                # drop rows from the start
+                del self.displayrows[:self.datastarty-olddatastarty]
+                # fetch new items
+                for i in xrange(olddatastarty+self.mainsizey,
+                                self.datastarty+self.mainsizey):
+                    try:
+                        row = self.getrow(i)
+                    except IndexError:
+                        # we didn't have enough objects to fill the screen
+                        break
+                    self.displayrows.append(row)
+            self.calcwidths()
+
+        # Make sure that the cursor didn't leave the data area horizontally
+        if x < 0:
+            x = 0
+        elif x >= self.datasizex:
+            x = max(0, self.datasizex-1)
+
+        # Make sure that the cursor stays on screen horizontally
+        if x < self.datastartx+scrollborderx:
+            self.datastartx = max(0, x-scrollborderx)
+        elif x >= self.datastartx+self.mainsizex-scrollborderx:
+            self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
+                                         self.datasizex-self.mainsizex))
+
+        if x == oldx and y == oldy and (x != newx or y != newy): # couldn't move
+            self.browser.beep()
+        else:
+            self.curx = x
+            self.cury = y
+            self.calcdisplayattr()
+
+    def sort(self, key, reverse=False):
+        """
+        Sort the currently list of items using the key function ``key``. If
+        ``reverse`` is true the sort order is reversed.
+        """
+        curitem = self.items[self.cury] # Remember where the cursor is now
+
+        # Sort items
+        def realkey(item):
+            return key(item.item)
+        self.items = ipipe.deque(sorted(self.items, key=realkey, reverse=reverse))
+
+        # Find out where the object under the cursor went
+        cury = self.cury
+        for (i, item) in enumerate(self.items):
+            if item is curitem:
+                cury = i
+                break
+
+        self.moveto(self.curx, cury, refresh=True)
+
+
+class ibrowse(ipipe.Display):
+    # Show this many lines from the previous screen when paging horizontally
+    pageoverlapx = 1
+
+    # Show this many lines from the previous screen when paging vertically
+    pageoverlapy = 1
+
+    # Start scrolling when the cursor is less than this number of columns
+    # away from the left or right screen edge
+    scrollborderx = 10
+
+    # Start scrolling when the cursor is less than this number of lines
+    # away from the top or bottom screen edge
+    scrollbordery = 5
+
+    # Accelerate by this factor when scrolling horizontally
+    acceleratex = 1.05
+
+    # Accelerate by this factor when scrolling vertically
+    acceleratey = 1.05
+
+    # The maximum horizontal scroll speed
+    # (as a factor of the screen width (i.e. 0.5 == half a screen width)
+    maxspeedx = 0.5
+
+    # The maximum vertical scroll speed
+    # (as a factor of the screen height (i.e. 0.5 == half a screen height)
+    maxspeedy = 0.5
+
+    # The maximum number of header lines for browser level
+    # if the nesting is deeper, only the innermost levels are displayed
+    maxheaders = 5
+
+    # The approximate maximum length of a column entry
+    maxattrlength = 200
+
+    # Styles for various parts of the GUI
+    style_objheadertext = astyle.Style.fromstr("white:black:bold|reverse")
+    style_objheadernumber = astyle.Style.fromstr("white:blue:bold|reverse")
+    style_objheaderobject = astyle.Style.fromstr("white:black:reverse")
+    style_colheader = astyle.Style.fromstr("blue:white:reverse")
+    style_colheaderhere = astyle.Style.fromstr("green:black:bold|reverse")
+    style_colheadersep = astyle.Style.fromstr("blue:black:reverse")
+    style_number = astyle.Style.fromstr("blue:white:reverse")
+    style_numberhere = astyle.Style.fromstr("green:black:bold|reverse")
+    style_sep = astyle.Style.fromstr("blue:black")
+    style_data = astyle.Style.fromstr("white:black")
+    style_datapad = astyle.Style.fromstr("blue:black:bold")
+    style_footer = astyle.Style.fromstr("black:white")
+    style_report = astyle.Style.fromstr("white:black")
+
+    # Column separator in header
+    headersepchar = "|"
+
+    # Character for padding data cell entries
+    datapadchar = "."
+
+    # Column separator in data area
+    datasepchar = "|"
+
+    # Character to use for "empty" cell (i.e. for non-existing attributes)
+    nodatachar = "-"
+
+    # Prompts for modes that require keyboard input
+    prompts = {
+        "goto": "goto object #: ",
+        "find": "find expression: ",
+        "findbackwards": "find backwards expression: "
+    }
+
+    # Maps curses key codes to "function" names
+    keymap = {
+        ord("q"): "quit",
+        curses.KEY_UP: "up",
+        curses.KEY_DOWN: "down",
+        curses.KEY_PPAGE: "pageup",
+        curses.KEY_NPAGE: "pagedown",
+        curses.KEY_LEFT: "left",
+        curses.KEY_RIGHT: "right",
+        curses.KEY_HOME: "home",
+        curses.KEY_END: "end",
+        ord("<"): "prevattr",
+        0x1b:     "prevattr", # SHIFT-TAB
+        ord(">"): "nextattr",
+        ord("\t"):"nextattr", # TAB
+        ord("p"): "pick",
+        ord("P"): "pickattr",
+        ord("C"): "pickallattrs",
+        ord("m"): "pickmarked",
+        ord("M"): "pickmarkedattr",
+        ord("\n"): "enterdefault",
+        # FIXME: What's happening here?
+        8: "leave",
+        127: "leave",
+        curses.KEY_BACKSPACE: "leave",
+        ord("x"): "leave",
+        ord("h"): "help",
+        ord("e"): "enter",
+        ord("E"): "enterattr",
+        ord("d"): "detail",
+        ord("D"): "detailattr",
+        ord(" "): "tooglemark",
+        ord("r"): "markrange",
+        ord("v"): "sortattrasc",
+        ord("V"): "sortattrdesc",
+        ord("g"): "goto",
+        ord("f"): "find",
+        ord("b"): "findbackwards",
+    }
+
+    def __init__(self, *attrs):
+        """
+        Create a new browser. If ``attrs`` is not empty, it is the list
+        of attributes that will be displayed in the browser, otherwise
+        these will be determined by the objects on screen.
+        """
+        self.attrs = attrs
+
+        # Stack of browser levels
+        self.levels = []
+        # how many colums to scroll (Changes when accelerating)
+        self.stepx = 1.
+
+        # how many rows to scroll (Changes when accelerating)
+        self.stepy = 1.
+
+        # Beep on the edges of the data area? (Will be set to ``False``
+        # once the cursor hits the edge of the screen, so we don't get
+        # multiple beeps).
+        self._dobeep = True
+
+        # Cache for registered ``curses`` colors and styles.
+        self._styles = {}
+        self._colors = {}
+        self._maxcolor = 1
+
+        # How many header lines do we want to paint (the numbers of levels
+        # we have, but with an upper bound)
+        self._headerlines = 1
+
+        # Index of first header line
+        self._firstheaderline = 0
+
+        # curses window
+        self.scr = None
+        # report in the footer line (error, executed command etc.)
+        self._report = None
+
+        # value to be returned to the caller (set by commands)
+        self.returnvalue = None
+
+        # The mode the browser is in
+        # e.g. normal browsing or entering an argument for a command
+        self.mode = "default"
+
+        # The partially entered row number for the goto command
+        self.goto = ""
+
+    def nextstepx(self, step):
+        """
+        Accelerate horizontally.
+        """
+        return max(1., min(step*self.acceleratex,
+                           self.maxspeedx*self.levels[-1].mainsizex))
+
+    def nextstepy(self, step):
+        """
+        Accelerate vertically.
+        """
+        return max(1., min(step*self.acceleratey,
+                           self.maxspeedy*self.levels[-1].mainsizey))
+
+    def getstyle(self, style):
+        """
+        Register the ``style`` with ``curses`` or get it from the cache,
+        if it has been registered before.
+        """
+        try:
+            return self._styles[style.fg, style.bg, style.attrs]
+        except KeyError:
+            attrs = 0
+            for b in astyle.A2CURSES:
+                if style.attrs & b:
+                    attrs |= astyle.A2CURSES[b]
+            try:
+                color = self._colors[style.fg, style.bg]
+            except KeyError:
+                curses.init_pair(
+                    self._maxcolor,
+                    astyle.COLOR2CURSES[style.fg],
+                    astyle.COLOR2CURSES[style.bg]
+                )
+                color = curses.color_pair(self._maxcolor)
+                self._colors[style.fg, style.bg] = color
+                self._maxcolor += 1
+            c = color | attrs
+            self._styles[style.fg, style.bg, style.attrs] = c
+            return c
+
+    def addstr(self, y, x, begx, endx, text, style):
+        """
+        A version of ``curses.addstr()`` that can handle ``x`` coordinates
+        that are outside the screen.
+        """
+        text2 = text[max(0, begx-x):max(0, endx-x)]
+        if text2:
+            self.scr.addstr(y, max(x, begx), text2, self.getstyle(style))
+        return len(text)
+
+    def addchr(self, y, x, begx, endx, c, l, style):
+        x0 = max(x, begx)
+        x1 = min(x+l, endx)
+        if x1>x0:
+            self.scr.addstr(y, x0, c*(x1-x0), self.getstyle(style))
+        return l
+
+    def _calcheaderlines(self, levels):
+        # Calculate how many headerlines do we have to display, if we have
+        # ``levels`` browser levels
+        if levels is None:
+            levels = len(self.levels)
+        self._headerlines = min(self.maxheaders, levels)
+        self._firstheaderline = levels-self._headerlines
+
+    def getstylehere(self, style):
+        """
+        Return a style for displaying the original style ``style``
+        in the row the cursor is on.
+        """
+        return astyle.Style(style.fg, style.bg, style.attrs | astyle.A_BOLD)
+
+    def report(self, msg):
+        """
+        Store the message ``msg`` for display below the footer line. This
+        will be displayed as soon as the screen is redrawn.
+        """
+        self._report = msg
+
+    def enter(self, item, mode, *attrs):
+        """
+        Enter the object ``item`` in the mode ``mode``. If ``attrs`` is
+        specified, it will be used as a fixed list of attributes to display.
+        """
+        try:
+            iterator = ipipe.xiter(item, mode)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception, exc:
+            curses.beep()
+            self.report(exc)
+        else:
+            self._calcheaderlines(len(self.levels)+1)
+            level = _BrowserLevel(
+                self,
+                item,
+                iterator,
+                self.scrsizey-1-self._headerlines-2,
+                *attrs
+            )
+            self.levels.append(level)
+
+    def startkeyboardinput(self, mode):
+        """
+        Enter mode ``mode``, which requires keyboard input.
+        """
+        self.mode = mode
+        self.keyboardinput = ""
+        self.cursorpos = 0
+
+    def executekeyboardinput(self, mode):
+        exe = getattr(self, "exe_%s" % mode, None)
+        if exe is not None:
+            exe()
+            self.mode = "default"
+
+    def keylabel(self, keycode):
+        """
+        Return a pretty name for the ``curses`` key ``keycode`` (used in the
+        help screen and in reports about unassigned keys).
+        """
+        if keycode <= 0xff:
+            specialsnames = {
+                ord("\n"): "RETURN",
+                ord(" "): "SPACE",
+                ord("\t"): "TAB",
+                ord("\x7f"): "DELETE",
+                ord("\x08"): "BACKSPACE",
+            }
+            if keycode in specialsnames:
+                return specialsnames[keycode]
+            return repr(chr(keycode))
+        for name in dir(curses):
+            if name.startswith("KEY_") and getattr(curses, name) == keycode:
+                return name
+        return str(keycode)
+
+    def beep(self, force=False):
+        if force or self._dobeep:
+            curses.beep()
+            # don't beep again (as long as the same key is pressed)
+            self._dobeep = False
+
+    def cmd_quit(self):
+        self.returnvalue = None
+        return True
+
+    def cmd_up(self):
+        level = self.levels[-1]
+        self.report("up")
+        level.moveto(level.curx, level.cury-self.stepy)
+
+    def cmd_down(self):
+        level = self.levels[-1]
+        self.report("down")
+        level.moveto(level.curx, level.cury+self.stepy)
+
+    def cmd_pageup(self):
+        level = self.levels[-1]
+        self.report("page up")
+        level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
+
+    def cmd_pagedown(self):
+        level = self.levels[-1]
+        self.report("page down")
+        level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
+
+    def cmd_left(self):
+        level = self.levels[-1]
+        self.report("left")
+        level.moveto(level.curx-self.stepx, level.cury)
+
+    def cmd_right(self):
+        level = self.levels[-1]
+        self.report("right")
+        level.moveto(level.curx+self.stepx, level.cury)
+
+    def cmd_home(self):
+        level = self.levels[-1]
+        self.report("home")
+        level.moveto(0, level.cury)
+
+    def cmd_end(self):
+        level = self.levels[-1]
+        self.report("end")
+        level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
+
+    def cmd_prevattr(self):
+        level = self.levels[-1]
+        if level.displayattr[0] is None or level.displayattr[0] == 0:
+            self.beep()
+        else:
+            self.report("prevattr")
+            pos = 0
+            for (i, attrname) in enumerate(level.displayattrs):
+                if i == level.displayattr[0]-1:
+                    break
+                pos += level.colwidths[attrname] + 1
+            level.moveto(pos, level.cury)
+
+    def cmd_nextattr(self):
+        level = self.levels[-1]
+        if level.displayattr[0] is None or level.displayattr[0] == len(level.displayattrs)-1:
+            self.beep()
+        else:
+            self.report("nextattr")
+            pos = 0
+            for (i, attrname) in enumerate(level.displayattrs):
+                if i == level.displayattr[0]+1:
+                    break
+                pos += level.colwidths[attrname] + 1
+            level.moveto(pos, level.cury)
+
+    def cmd_pick(self):
+        level = self.levels[-1]
+        self.returnvalue = level.items[level.cury].item
+        return True
+
+    def cmd_pickattr(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        attr = ipipe._getattr(level.items[level.cury].item, attrname)
+        if attr is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+        else:
+            self.returnvalue = attr
+            return True
+
+    def cmd_pickallattrs(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        result = []
+        for cache in level.items:
+            attr = ipipe._getattr(cache.item, attrname)
+            if attr is not ipipe._default:
+                result.append(attr)
+        self.returnvalue = result
+        return True
+
+    def cmd_pickmarked(self):
+        level = self.levels[-1]
+        self.returnvalue = [cache.item for cache in level.items if cache.marked]
+        return True
+
+    def cmd_pickmarkedattr(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        result = []
+        for cache in level.items:
+            if cache.marked:
+                attr = ipipe._getattr(cache.item, attrname)
+                if attr is not ipipe._default:
+                    result.append(attr)
+        self.returnvalue = result
+        return True
+
+    def cmd_markrange(self):
+        level = self.levels[-1]
+        self.report("markrange")
+        start = None
+        if level.items:
+            for i in xrange(level.cury, -1, -1):
+                if level.items[i].marked:
+                    start = i
+                    break
+        if start is None:
+            self.report(CommandError("no mark before cursor"))
+            curses.beep()
+        else:
+            for i in xrange(start, level.cury+1):
+                cache = level.items[i]
+                if not cache.marked:
+                    cache.marked = True
+                    level.marked += 1
+
+    def cmd_enterdefault(self):
+        level = self.levels[-1]
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            self.report("entering object (default mode)...")
+            self.enter(item, "default")
+
+    def cmd_leave(self):
+        self.report("leave")
+        if len(self.levels) > 1:
+            self._calcheaderlines(len(self.levels)-1)
+            self.levels.pop(-1)
+        else:
+            self.report(CommandError("This is the last level"))
+            curses.beep()
+
+    def cmd_enter(self):
+        level = self.levels[-1]
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            self.report("entering object...")
+            self.enter(item, None)
+
+    def cmd_enterattr(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            attr = ipipe._getattr(item, attrname)
+            if attr is ipipe._default:
+                self.report(AttributeError(ipipe._attrname(attrname)))
+            else:
+                self.report("entering object attribute %s..." % ipipe._attrname(attrname))
+                self.enter(attr, None)
+
+    def cmd_detail(self):
+        level = self.levels[-1]
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            self.report("entering detail view for object...")
+            self.enter(item, "detail")
+
+    def cmd_detailattr(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            attr = ipipe._getattr(item, attrname)
+            if attr is ipipe._default:
+                self.report(AttributeError(ipipe._attrname(attrname)))
+            else:
+                self.report("entering detail view for attribute...")
+                self.enter(attr, "detail")
+
+    def cmd_tooglemark(self):
+        level = self.levels[-1]
+        self.report("toggle mark")
+        try:
+            item = level.items[level.cury]
+        except IndexError: # no items?
+            pass
+        else:
+            if item.marked:
+                item.marked = False
+                level.marked -= 1
+            else:
+                item.marked = True
+                level.marked += 1
+
+    def cmd_sortattrasc(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        self.report("sort by %s (ascending)" % ipipe._attrname(attrname))
+        def key(item):
+            try:
+                return ipipe._getattr(item, attrname, None)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        level.sort(key)
+
+    def cmd_sortattrdesc(self):
+        level = self.levels[-1]
+        attrname = level.displayattr[1]
+        if attrname is ipipe._default:
+            curses.beep()
+            self.report(AttributeError(ipipe._attrname(attrname)))
+            return
+        self.report("sort by %s (descending)" % ipipe._attrname(attrname))
+        def key(item):
+            try:
+                return ipipe._getattr(item, attrname, None)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        level.sort(key, reverse=True)
+
+    def cmd_goto(self):
+        self.startkeyboardinput("goto")
+
+    def exe_goto(self):
+        level = self.levels[-1]
+        if self.keyboardinput:
+            level.moveto(level.curx, int(self.keyboardinput))
+
+    def cmd_find(self):
+        self.startkeyboardinput("find")
+
+    def exe_find(self):
+        level = self.levels[-1]
+        if self.keyboardinput:
+            while True:
+                cury = level.cury
+                level.moveto(level.curx, cury+1)
+                if cury == level.cury:
+                    curses.beep()
+                    break
+                item = level.items[level.cury].item
+                try:
+                    if eval(self.keyboardinput, globals(), ipipe.AttrNamespace(item)):
+                        break
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except Exception, exc:
+                    self.report(exc)
+                    curses.beep()
+                    break # break on error
+
+    def cmd_findbackwards(self):
+        self.startkeyboardinput("findbackwards")
+
+    def exe_findbackwards(self):
+        level = self.levels[-1]
+        if self.keyboardinput:
+            while level.cury:
+                level.moveto(level.curx, level.cury-1)
+                item = level.items[level.cury].item
+                try:
+                    if eval(self.keyboardinput, globals(), ipipe.AttrNamespace(item)):
+                        break
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except Exception, exc:
+                    self.report(exc)
+                    curses.beep()
+                    break # break on error
+            else:
+                curses.beep()
+
+    def cmd_help(self):
+        """
+        The help command
+        """
+        for level in self.levels:
+            if isinstance(level.input, _BrowserHelp):
+                curses.beep()
+                self.report(CommandError("help already active"))
+                return
+
+        self.enter(_BrowserHelp(self), "default")
+
+    def _dodisplay(self, scr):
+        """
+        This method is the workhorse of the browser. It handles screen
+        drawing and the keyboard.
+        """
+        self.scr = scr
+        curses.halfdelay(1)
+        footery = 2
+
+        keys = []
+        for (key, cmd) in self.keymap.iteritems():
+            if cmd == "quit":
+                keys.append("%s=%s" % (self.keylabel(key), cmd))
+        for (key, cmd) in self.keymap.iteritems():
+            if cmd == "help":
+                keys.append("%s=%s" % (self.keylabel(key), cmd))
+        helpmsg = " | %s" % " ".join(keys)
+
+        scr.clear()
+        msg = "Fetching first batch of objects..."
+        (self.scrsizey, self.scrsizex) = scr.getmaxyx()
+        scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
+        scr.refresh()
+
+        lastc = -1
+
+        self.levels = []
+        # enter the first level
+        self.enter(self.input, ipipe.xiter(self.input, "default"), *self.attrs)
+
+        self._calcheaderlines(None)
+
+        while True:
+            level = self.levels[-1]
+            (self.scrsizey, self.scrsizex) = scr.getmaxyx()
+            level.mainsizey = self.scrsizey-1-self._headerlines-footery
+
+            # Paint object header
+            for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
+                lv = self.levels[i]
+                posx = 0
+                posy = i-self._firstheaderline
+                endx = self.scrsizex
+                if i: # not the first level
+                    msg = " (%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
+                    if not self.levels[i-1].exhausted:
+                        msg += "+"
+                    msg += ") "
+                    endx -= len(msg)+1
+                posx += self.addstr(posy, posx, 0, endx, " ibrowse #%d: " % i, self.style_objheadertext)
+                for (style, text) in lv.header:
+                    posx += self.addstr(posy, posx, 0, endx, text, self.style_objheaderobject)
+                    if posx >= endx:
+                        break
+                if i:
+                    posx += self.addstr(posy, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
+                posx += self.addchr(posy, posx, 0, self.scrsizex, " ", self.scrsizex-posx, self.style_objheadernumber)
+
+            if not level.items:
+                self.addchr(self._headerlines, 0, 0, self.scrsizex, " ", self.scrsizex, self.style_colheader)
+                self.addstr(self._headerlines+1, 0, 0, self.scrsizex, " <empty>", astyle.style_error)
+                scr.clrtobot()
+            else:
+                # Paint column headers
+                scr.move(self._headerlines, 0)
+                scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
+                scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
+                begx = level.numbersizex+3
+                posx = begx-level.datastartx
+                for attrname in level.displayattrs:
+                    strattrname = ipipe._attrname(attrname)
+                    cwidth = level.colwidths[attrname]
+                    header = strattrname.ljust(cwidth)
+                    if attrname == level.displayattr[1]:
+                        style = self.style_colheaderhere
+                    else:
+                        style = self.style_colheader
+                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, header, style)
+                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, self.headersepchar, self.style_colheadersep)
+                    if posx >= self.scrsizex:
+                        break
+                else:
+                    scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_colheader))
+
+                # Paint rows
+                posy = self._headerlines+1+level.datastarty
+                for i in xrange(level.datastarty, min(level.datastarty+level.mainsizey, len(level.items))):
+                    cache = level.items[i]
+                    if i == level.cury:
+                        style = self.style_numberhere
+                    else:
+                        style = self.style_number
+
+                    posy = self._headerlines+1+i-level.datastarty
+                    posx = begx-level.datastartx
+
+                    scr.move(posy, 0)
+                    scr.addstr(" %*d%s" % (level.numbersizex, i, " !"[cache.marked]), self.getstyle(style))
+                    scr.addstr(self.headersepchar, self.getstyle(self.style_sep))
+
+                    for attrname in level.displayattrs:
+                        cwidth = level.colwidths[attrname]
+                        try:
+                            (align, length, parts) = level.displayrows[i-level.datastarty][attrname]
+                        except KeyError:
+                            align = 2
+                            style = astyle.style_nodata
+                        padstyle = self.style_datapad
+                        sepstyle = self.style_sep
+                        if i == level.cury:
+                            padstyle = self.getstylehere(padstyle)
+                            sepstyle = self.getstylehere(sepstyle)
+                        if align == 2:
+                            posx += self.addchr(posy, posx, begx, self.scrsizex, self.nodatachar, cwidth, style)
+                        else:
+                            if align == 1:
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
+                            elif align == 0:
+                                pad1 = (cwidth-length)//2
+                                pad2 = cwidth-length-len(pad1)
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad1, padstyle)
+                            for (style, text) in parts:
+                                if i == level.cury:
+                                    style = self.getstylehere(style)
+                                posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
+                                if posx >= self.scrsizex:
+                                    break
+                            if align == -1:
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
+                            elif align == 0:
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad2, padstyle)
+                        posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
+                    else:
+                        scr.clrtoeol()
+
+                # Add blank row headers for the rest of the screen
+                for posy in xrange(posy+1, self.scrsizey-2):
+                    scr.addstr(posy, 0, " " * (level.numbersizex+2), self.getstyle(self.style_colheader))
+                    scr.clrtoeol()
+
+            posy = self.scrsizey-footery
+            # Display footer
+            scr.addstr(posy, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
+
+            if level.exhausted:
+                flag = ""
+            else:
+                flag = "+"
+
+            endx = self.scrsizex-len(helpmsg)-1
+            scr.addstr(posy, endx, helpmsg, self.getstyle(self.style_footer))
+
+            posx = 0
+            msg = " %d%s objects (%d marked): " % (len(level.items), flag, level.marked)
+            posx += self.addstr(posy, posx, 0, endx, msg, self.style_footer)
+            try:
+                item = level.items[level.cury].item
+            except IndexError: # empty
+                pass
+            else:
+                for (nostyle, text) in ipipe.xrepr(item, "footer"):
+                    if not isinstance(nostyle, int):
+                        posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
+                        if posx >= endx:
+                            break
+
+                attrstyle = [(astyle.style_default, "no attribute")]
+                attrname = level.displayattr[1]
+                if attrname is not ipipe._default and attrname is not None:
+                    posx += self.addstr(posy, posx, 0, endx, " | ", self.style_footer)
+                    posx += self.addstr(posy, posx, 0, endx, ipipe._attrname(attrname), self.style_footer)
+                    posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
+                    try:
+                        attr = ipipe._getattr(item, attrname)
+                    except (SystemExit, KeyboardInterrupt):
+                        raise
+                    except Exception, exc:
+                        attr = exc
+                    if attr is not ipipe._default:
+                        attrstyle = ipipe.xrepr(attr, "footer")
+                    for (nostyle, text) in attrstyle:
+                        if not isinstance(nostyle, int):
+                            posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
+                            if posx >= endx:
+                                break
+
+            try:
+                # Display input prompt
+                if self.mode in self.prompts:
+                    scr.addstr(self.scrsizey-1, 0,
+                               self.prompts[self.mode] + self.keyboardinput,
+                               self.getstyle(astyle.style_default))
+                # Display report
+                else:
+                    if self._report is not None:
+                        if isinstance(self._report, Exception):
+                            style = self.getstyle(astyle.style_error)
+                            if self._report.__class__.__module__ == "exceptions":
+                                msg = "%s: %s" % \
+                                      (self._report.__class__.__name__, self._report)
+                            else:
+                                msg = "%s.%s: %s" % \
+                                      (self._report.__class__.__module__,
+                                       self._report.__class__.__name__, self._report)
+                        else:
+                            style = self.getstyle(self.style_report)
+                            msg = self._report
+                        scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
+                        self._report = None
+                    else:
+                        scr.move(self.scrsizey-1, 0)
+            except curses.error:
+                # Protect against error from writing to the last line
+                pass
+            scr.clrtoeol()
+
+            # Position cursor
+            if self.mode in self.prompts:
+                scr.move(self.scrsizey-1, len(self.prompts[self.mode])+self.cursorpos)
+            else:
+                scr.move(
+                    1+self._headerlines+level.cury-level.datastarty,
+                    level.numbersizex+3+level.curx-level.datastartx
+                )
+            scr.refresh()
+
+            # Check keyboard
+            while True:
+                c = scr.getch()
+                if self.mode in self.prompts:
+                    if c in (8, 127, curses.KEY_BACKSPACE):
+                        if self.cursorpos:
+                            self.keyboardinput = self.keyboardinput[:self.cursorpos-1] + self.keyboardinput[self.cursorpos:]
+                            self.cursorpos -= 1
+                            break
+                        else:
+                            curses.beep()
+                    elif c == curses.KEY_LEFT:
+                        if self.cursorpos:
+                            self.cursorpos -= 1
+                            break
+                        else:
+                            curses.beep()
+                    elif c == curses.KEY_RIGHT:
+                        if self.cursorpos < len(self.keyboardinput):
+                            self.cursorpos += 1
+                            break
+                        else:
+                            curses.beep()
+                    elif c in (curses.KEY_UP, curses.KEY_DOWN): # cancel
+                        self.mode = "default"
+                        break
+                    elif c == ord("\n"):
+                        self.executekeyboardinput(self.mode)
+                        break
+                    elif c != -1:
+                        try:
+                            c = chr(c)
+                        except ValueError:
+                            curses.beep()
+                        else:
+                            if (self.mode == "goto" and not "0" <= c <= "9"):
+                                curses.beep()
+                            else:
+                                self.keyboardinput = self.keyboardinput[:self.cursorpos] + c + self.keyboardinput[self.cursorpos:]
+                                self.cursorpos += 1
+                                break # Redisplay
+                else:
+                    # if no key is pressed slow down and beep again
+                    if c == -1:
+                        self.stepx = 1.
+                        self.stepy = 1.
+                        self._dobeep = True
+                    else:
+                        # if a different key was pressed slow down and beep too
+                        if c != lastc:
+                            lastc = c
+                            self.stepx = 1.
+                            self.stepy = 1.
+                            self._dobeep = True
+                        cmdname = self.keymap.get(c, None)
+                        if cmdname is None:
+                            self.report(
+                                UnassignedKeyError("Unassigned key %s" %
+                                                   self.keylabel(c)))
+                        else:
+                            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
+                            if cmdfunc is None:
+                                self.report(
+                                    UnknownCommandError("Unknown command %r" %
+                                                        (cmdname,)))
+                            elif cmdfunc():
+                                returnvalue = self.returnvalue
+                                self.returnvalue = None
+                                return returnvalue
+                        self.stepx = self.nextstepx(self.stepx)
+                        self.stepy = self.nextstepy(self.stepy)
+                        curses.flushinp() # get rid of type ahead
+                        break # Redisplay
+        self.scr = None
+
+    def display(self):
+        return curses.wrapper(self._dodisplay)

IPython/Extensions/ipipe.py

@@ -1,3230 +1,1820 b''
 # -*- coding: iso-8859-1 -*-
 
 """
 ``ipipe`` provides classes to be used in an interactive Python session. Doing a
 ``from ipipe import *`` is the preferred way to do this. The name of all
 objects imported this way starts with ``i`` to minimize collisions.
 
 ``ipipe`` supports "pipeline expressions", which is something resembling Unix
 pipes. An example is:
 
     >>> ienv | isort("key.lower()")
 
 This gives a listing of all environment variables sorted by name.
 
 
 There are three types of objects in a pipeline expression:
 
 * ``Table``s: These objects produce items. Examples are ``ls`` (listing the
   current directory, ``ienv`` (listing environment variables), ``ipwd`` (listing
   user account) and ``igrp`` (listing user groups). A ``Table`` must be the
   first object in a pipe expression.
 
 * ``Pipe``s: These objects sit in the middle of a pipe expression. They
   transform the input in some way (e.g. filtering or sorting it). Examples are:
   ``ifilter`` (which filters the input pipe), ``isort`` (which sorts the input
   pipe) and ``ieval`` (which evaluates a function or expression for each object
   in the input pipe).
 
 * ``Display``s: These objects can be put as the last object in a pipeline
   expression. There are responsible for displaying the result of the pipeline
   expression. If a pipeline expression doesn't end in a display object a default
   display objects will be used. One example is ``browse`` which is a ``curses``
   based browser.
 
 
 Adding support for pipeline expressions to your own objects can be done through
 three extensions points (all of them optional):
 
 * An object that will be displayed as a row by a ``Display`` object should
   implement the method ``__xattrs__(self, mode)``. This method must return a
   sequence of attribute names. This sequence may also contain integers, which
   will be treated as sequence indizes. Also supported is ``None``, which uses
   the object itself and callables which will be called with the object as the
   an argument. If ``__xattrs__()`` isn't implemented ``(None,)`` will be used as
   the attribute sequence (i.e. the object itself (it's ``repr()`` format) will
   be being displayed. The global function ``xattrs()`` implements this
   functionality.
 
 * When an object ``foo`` is displayed in the header, footer or table cell of the
   browser ``foo.__xrepr__(mode)`` is called. Mode can be ``"header"`` or
   ``"footer"`` for the header or footer line and ``"cell"`` for a table cell.
   ``__xrepr__()```must return an iterable (e.g. by being a generator) which
   produces the following items: The first item should be a tuple containing
   the alignment (-1 left aligned, 0 centered and 1 right aligned) and whether
   the complete output must be displayed or if the browser is allowed to stop
   output after enough text has been produced (e.g. a syntax highlighted text
   line would use ``True``, but for a large data structure (i.e. a nested list,
   tuple or dictionary) ``False`` would be used). The other output ``__xrepr__()``
   may produce is tuples of ``Style```objects and text (which contain the text
   representation of the object; see the ``astyle`` module). If ``__xrepr__()``
   recursively outputs a data structure the function ``xrepr(object, mode)`` can
   be used and ``"default"`` must be passed as the mode in these calls. This in
   turn calls the ``__xrepr__()`` method on ``object`` (or uses ``repr(object)``
   as the string representation if ``__xrepr__()`` doesn't exist).
 
 * Objects that can be iterated by ``Pipe``s must implement the method
 ``__xiter__(self, mode)``. ``mode`` can take the following values:
 
   - ``"default"``: This is the default value and ist always used by pipeline
     expressions. Other values are only used in the browser.
   - ``None``: This value is passed by the browser. The object must return an
     iterable of ``XMode`` objects describing all modes supported by the object.
     (This should never include ``"default"`` or ``None``).
   - Any other value that the object supports.
 
   The global function ``xiter()`` can be called to get such an iterator. If
   the method ``_xiter__`` isn't implemented, ``xiter()`` falls back to
   ``__iter__``. In addition to that, dictionaries and modules receive special
   treatment (returning an iterator over ``(key, value)`` pairs). This makes it
   possible to use dictionaries and modules in pipeline expressions, for example:
 
       >>> import sys
       >>> sys | ifilter("isinstance(value, int)") | idump
       key        |value
       api_version|      1012
       dllhandle  | 503316480
       hexversion |  33817328
       maxint     |2147483647
       maxunicode |     65535
       >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
       ...
 
   Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
   refer to the object to be filtered or sorted via the variable ``_`` and to any
   of the attributes of the object, i.e.:
 
       >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
 
   does the same as
 
       >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
 
   In addition to expression strings, it's possible to pass callables (taking
   the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``:
 
       >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
       ...     | ieval(lambda _: (_.key, hex(_.value))) | idump
       0          |1
       api_version|0x3f4
       dllhandle  |0x1e000000
       hexversion |0x20402f0
       maxint     |0x7fffffff
       maxunicode |0xffff
 """
 
 import sys, os, os.path, stat, glob, new, csv, datetime, types
 import textwrap, itertools, mimetypes
 
 try: # Python 2.3 compatibility
     import collections
 except ImportError:
     deque = list
 else:
     deque = collections.deque
 
 try: # Python 2.3 compatibility
     set
 except NameError:
     import sets
     set = sets.Set
 
 try: # Python 2.3 compatibility
     sorted
 except NameError:
     def sorted(iterator, key=None, reverse=False):
         items = list(iterator)
         if key is not None:
             items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
         else:
             items.sort()
         if reverse:
             items.reverse()
         return items
 
 try:
     import pwd
 except ImportError:
     pwd = None
 
 try:
     import grp
 except ImportError:
     grp = None
 
-try:
-    import curses
-except ImportError:
-    curses = None
-
 import path
 try:
     from IPython import genutils
 except ImportError:
     pass
 
 import astyle
 
 
 __all__ = [
     "ifile", "ils", "iglob", "iwalk", "ipwdentry", "ipwd", "igrpentry", "igrp",
     "icsv", "ix", "ichain", "isort", "ifilter", "ieval", "ienum", "ienv",
     "idump", "iless"
 ]
 
 
 os.stat_float_times(True) # enable microseconds
 
 
-class _AttrNamespace(object):
+class AttrNamespace(object):
     """
-    Internal helper class that is used for providing a namespace for evaluating
-    expressions containg attribute names of an object.
+    Helper class that is used for providing a namespace for evaluating
+    expressions containing attribute names of an object.
     """
     def __init__(self, wrapped):
         self.wrapped = wrapped
 
     def __getitem__(self, name):
         if name == "_":
             return self.wrapped
         try:
             return getattr(self.wrapped, name)
         except AttributeError:
             raise KeyError(name)
 
 # Python 2.3 compatibility
 # use eval workaround to find out which names are used in the
 # eval string and put them into the locals. This works for most
 # normal uses case, bizarre ones like accessing the locals()
 # will fail
 try:
-    eval("_", None, _AttrNamespace(None))
+    eval("_", None, AttrNamespace(None))
 except TypeError:
     real_eval = eval
     def eval(codestring, _globals, _locals):
         """
         eval(source[, globals[, locals]]) -> value
 
         Evaluate the source in the context of globals and locals.
         The source may be a string representing a Python expression
         or a code object as returned by compile().
         The globals must be a dictionary and locals can be any mappping.
 
         This function is a workaround for the shortcomings of
         Python 2.3's eval.
         """
 
         code = compile(codestring, "_eval", "eval")
         newlocals = {}
         for name in code.co_names:
             try:
                 newlocals[name] = _locals[name]
             except KeyError:
                 pass
         return real_eval(code, _globals, newlocals)
 
 
 _default = object()
 
 def item(iterator, index, default=_default):
     """
     Return the ``index``th item from the iterator ``iterator``.
     ``index`` must be an integer (negative integers are relative to the
     end (i.e. the last item produced by the iterator)).
 
     If ``default`` is given, this will be the default value when
     the iterator doesn't contain an item at this position. Otherwise an
     ``IndexError`` will be raised.
 
     Note that using this function will partially or totally exhaust the
     iterator.
     """
     i = index
     if i>=0:
         for item in iterator:
             if not i:
                 return item
             i -= 1
     else:
         i = -index
         cache = deque()
         for item in iterator:
             cache.append(item)
             if len(cache)>i:
                 cache.popleft()
         if len(cache)==i:
             return cache.popleft()
     if default is _default:
         raise IndexError(index)
     else:
         return default
 
 
 class Table(object):
     """
     A ``Table`` is an object that produces items (just like a normal Python
     iterator/generator does) and can be used as the first object in a pipeline
     expression. The displayhook will open the default browser for such an object
     (instead of simply printing the ``repr()`` result).
     """
 
     # We want to support ``foo`` and ``foo()`` in pipeline expression:
     # So we implement the required operators (``|`` and ``+``) in the metaclass,
     # instantiate the class and forward the operator to the instance
     class __metaclass__(type):
         def __iter__(self):
             return iter(self())
 
         def __or__(self, other):
             return self() | other
 
         def __add__(self, other):
             return self() + other
 
         def __radd__(self, other):
             return other + self()
 
         def __getitem__(self, index):
             return self()[index]
 
     def __getitem__(self, index):
         return item(self, index)
 
     def __contains__(self, item):
         for haveitem in self:
             if item == haveitem:
                 return True
         return False
 
     def __or__(self, other):
         # autoinstantiate right hand side
         if isinstance(other, type) and issubclass(other, (Table, Display)):
             other = other()
         # treat simple strings and functions as ``ieval`` instances
         elif not isinstance(other, Display) and not isinstance(other, Table):
             other = ieval(other)
         # forward operations to the right hand side
         return other.__ror__(self)
 
     def __add__(self, other):
         # autoinstantiate right hand side
         if isinstance(other, type) and issubclass(other, Table):
             other = other()
         return ichain(self, other)
 
     def __radd__(self, other):
         # autoinstantiate left hand side
         if isinstance(other, type) and issubclass(other, Table):
             other = other()
         return ichain(other, self)
 
     def __iter__(self):
         return xiter(self, "default")
 
 
 class Pipe(Table):
     """
     A ``Pipe`` is an object that can be used in a pipeline expression. It
     processes the objects it gets from its input ``Table``/``Pipe``. Note that
     a ``Pipe`` object can't be used as the first object in a pipeline
     expression, as it doesn't produces items itself.
     """
     class __metaclass__(Table.__metaclass__):
         def __ror__(self, input):
             return input | self()
 
     def __ror__(self, input):
         # autoinstantiate left hand side
         if isinstance(input, type) and issubclass(input, Table):
             input = input()
         self.input = input
         return self
 
 
 def _getattr(obj, name, default=_default):
     """
     Internal helper for getting an attribute of an item. If ``name`` is ``None``
     return the object itself. If ``name`` is an integer, use ``__getitem__``
     instead. If the attribute or item does not exist, return ``default``.
     """
     if name is None:
         return obj
     elif isinstance(name, basestring):
         if name.endswith("()"):
             return getattr(obj, name[:-2], default)()
         else:
             return getattr(obj, name, default)
     elif callable(name):
         try:
             return name(obj)
         except AttributeError:
             return default
     else:
         try:
             return obj[name]
         except IndexError:
             return default
 
 
 def _attrname(name):
     """
     Internal helper that gives a proper name for the attribute ``name``
     (which might be ``None`` or an ``int``).
     """
     if name is None:
         return "_"
     elif isinstance(name, basestring):
         return name
     elif callable(name):
         return getattr(name, "__xname__", name.__name__)
     else:
         return str(name)
 
 
 def xrepr(item, mode):
     try:
         func = item.__xrepr__
     except AttributeError:
         pass
     else:
         try:
             for x in func(mode):
                 yield x
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception:
             yield (-1, True)
             yield (astyle.style_default, repr(item))
         return
     if item is None:
         yield (-1, True)
         yield (astyle.style_type_none, repr(item))
     elif isinstance(item, bool):
         yield (-1, True)
         yield (astyle.style_type_bool, repr(item))
     elif isinstance(item, str):
         yield (-1, True)
         if mode == "cell":
             yield (astyle.style_default, repr(item.expandtabs(tab))[1:-1])
         else:
             yield (astyle.style_default, repr(item))
     elif isinstance(item, unicode):
         yield (-1, True)
         if mode == "cell":
             yield (astyle.style_default, repr(item.expandtabs(tab))[2:-1])
         else:
             yield (astyle.style_default, repr(item))
     elif isinstance(item, (int, long, float)):
         yield (1, True)
         yield (astyle.style_type_number, repr(item))
     elif isinstance(item, complex):
         yield (-1, True)
         yield (astyle.style_type_number, repr(item))
     elif isinstance(item, datetime.datetime):
         yield (-1, True)
         if mode == "cell":
             # Don't use strftime() here, as this requires year >= 1900
             yield (astyle.style_type_datetime,
                    "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
                         (item.year, item.month, item.day,
                          item.hour, item.minute, item.second,
                          item.microsecond),
                     )
         else:
             yield (astyle.style_type_datetime, repr(item))
     elif isinstance(item, datetime.date):
         yield (-1, True)
         if mode == "cell":
             yield (astyle.style_type_datetime,
                    "%04d-%02d-%02d" % (item.year, item.month, item.day))
         else:
             yield (astyle.style_type_datetime, repr(item))
     elif isinstance(item, datetime.time):
         yield (-1, True)
         if mode == "cell":
             yield (astyle.style_type_datetime,
                     "%02d:%02d:%02d.%06d" % \
                         (item.hour, item.minute, item.second, item.microsecond))
         else:
             yield (astyle.style_type_datetime, repr(item))
     elif isinstance(item, datetime.timedelta):
         yield (-1, True)
         yield (astyle.style_type_datetime, repr(item))
     elif isinstance(item, Exception):
         yield (-1, True)
         if item.__class__.__module__ == "exceptions":
             classname = item.__class__.__name__
         else:
             classname = "%s.%s" % \
                 (item.__class__.__module__, item.__class__.__name__)
         if mode == "header" or mode == "footer":
             yield (astyle.style_error, "%s: %s" % (classname, item))
         else:
             yield (astyle.style_error, classname)
     elif isinstance(item, (list, tuple)):
         yield (-1, False)
         if mode == "header" or mode == "footer":
             if item.__class__.__module__ == "__builtin__":
                 classname = item.__class__.__name__
             else:
                 classname = "%s.%s" % \
                     (item.__class__.__module__,item.__class__.__name__)
             yield (astyle.style_default,
                    "<%s object with %d items at 0x%x>" % \
                        (classname, len(item), id(item)))
         else:
             if isinstance(item, list):
                 yield (astyle.style_default, "[")
                 end = "]"
             else:
                 yield (astyle.style_default, "(")
                 end = ")"
             for (i, subitem) in enumerate(item):
                 if i:
                     yield (astyle.style_default, ", ")
                 for part in xrepr(subitem, "default"):
                     yield part
             yield (astyle.style_default, end)
     elif isinstance(item, (dict, types.DictProxyType)):
         yield (-1, False)
         if mode == "header" or mode == "footer":
             if item.__class__.__module__ == "__builtin__":
                 classname = item.__class__.__name__
             else:
                 classname = "%s.%s" % \
                     (item.__class__.__module__,item.__class__.__name__)
             yield (astyle.style_default,
                    "<%s object with %d items at 0x%x>" % \
                     (classname, len(item), id(item)))
         else:
             if isinstance(item, dict):
                 yield (astyle.style_default, "{")
                 end = "}"
             else:
                 yield (astyle.style_default, "dictproxy((")
                 end = "})"
             for (i, (key, value)) in enumerate(item.iteritems()):
                 if i:
                     yield (astyle.style_default, ", ")
                 for part in xrepr(key, "default"):
                     yield part
                 yield (astyle.style_default, ": ")
                 for part in xrepr(value, "default"):
                     yield part
             yield (astyle.style_default, end)
     else:
         yield (-1, True)
         yield (astyle.style_default, repr(item))
 
 
 def xattrs(item, mode):
     try:
         func = item.__xattrs__
     except AttributeError:
         if mode == "detail":
             return dir(item)
         else:
             return (None,)
     else:
         try:
             return func(mode)
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception:
             return (None,)
 
 
 def xiter(item, mode):
     if mode == "detail":
         def items():
             for name in xattrs(item, mode):
                 yield XAttr(item, name)
         return items()
     try:
         func = item.__xiter__
     except AttributeError:
         if isinstance(item, (dict, types.DictProxyType)):
             def items(item):
                 fields = ("key", "value")
                 for (key, value) in item.iteritems():
                     yield Fields(fields, key=key, value=value)
             return items(item)
         elif isinstance(item, new.module):
             def items(item):
                 fields = ("key", "value")
                 for key in sorted(item.__dict__):
                     yield Fields(fields, key=key, value=getattr(item, key))
             return items(item)
         elif isinstance(item, basestring):
             if not len(item):
                 raise ValueError("can't enter empty string")
             lines = item.splitlines()
             if len(lines) <= 1:
                 raise ValueError("can't enter one line string")
             return iter(lines)
         return iter(item)
     else:
         return iter(func(mode)) # iter() just to be safe
 
 
 class ichain(Pipe):
     """
     Chains multiple ``Table``s into one.
     """
 
     def __init__(self, *iters):
         self.iters = iters
 
     def __xiter__(self, mode):
         return itertools.chain(*self.iters)
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             for (i, item) in enumerate(self.iters):
                 if i:
                     yield (astyle.style_default, "+")
                 if isinstance(item, Pipe):
                     yield (astyle.style_default, "(")
                 for part in xrepr(item, mode):
                     yield part
                 if isinstance(item, Pipe):
                     yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         args = ", ".join([repr(it) for it in self.iters])
         return "%s.%s(%s)" % \
             (self.__class__.__module__, self.__class__.__name__, args)
 
 
 class ifile(path.path):
     """
     file (or directory) object.
     """
 
     def __add_(self, other):
         return ifile(path._base(self) + other)
 
     def __radd_(self, other):
         return ifile(other + path._base(self))
 
     def __div_(self, other):
         return ifile(path.__div__(self, other))
 
     def getcwd():
         """ Return the current working directory as a path object. """
         return ifile(path.path.getcwd())
     getcwd = staticmethod(getcwd)
 
     def abspath(self):
         return ifile(path.path.abspath(self))
 
     def normcase(self):
         return ifile(path.path.normcase(self))
 
     def normpath(self):
         return ifile(path.path.normpath(self))
 
     def realpath(self):
         return ifile(path.path.realpath(self))
 
     def expanduser(self):
         return ifile(path.path.expanduser(self))
 
     def expandvars(self):
         return ifile(path.path.expandvars(self))
 
     def dirname(self):
         return ifile(path.path.dirname(self))
 
     parent = property(dirname, None, None, path.path.parent.__doc__)
 
     def splitpath(self):
         (parent, child) = path.path.splitpath(self)
         return (ifile(parent), child)
 
     def splitdrive(self):
         (drive, rel) = path.path.splitdrive(self)
         return (ifile(drive), rel)
 
     def splitext(self):
         (filename, ext) = path.path.splitext(self)
         return (ifile(filename), ext)
 
     if hasattr(path.path, "splitunc"):
         def splitunc(self):
             (unc, rest) = path.path.splitunc(self)
             return (ifile(unc), rest)
 
         def _get_uncshare(self):
             unc, r = os.path.splitunc(self)
             return ifile(unc)
 
         uncshare = property(
             _get_uncshare, None, None,
             """ The UNC mount point for this path.
             This is empty for paths on local drives. """)
 
     def joinpath(self, *args):
         return ifile(path.path.joinpath(self, *args))
 
     def splitall(self):
         return map(ifile, path.path.splitall(self))
 
     def relpath(self):
         return ifile(path.path.relpath(self))
 
     def relpathto(self, dest):
         return ifile(path.path.relpathto(self, dest))
 
     def listdir(self, pattern=None):
         return [ifile(child) for child in path.path.listdir(self, pattern)]
 
     def dirs(self, pattern=None):
         return [ifile(child) for child in path.path.dirs(self, pattern)]
 
     def files(self, pattern=None):
         return [ifile(child) for child in path.path.files(self, pattern)]
 
     def walk(self, pattern=None):
         for child in path.path.walk(self, pattern):
             yield ifile(child)
 
     def walkdirs(self, pattern=None):
         for child in path.path.walkdirs(self, pattern):
             yield ifile(child)
 
     def walkfiles(self, pattern=None):
         for child in path.path.walkfiles(self, pattern):
             yield ifile(child)
 
     def glob(self, pattern):
         return map(ifile, path.path.glob(self, pattern))
 
     if hasattr(os, 'readlink'):
         def readlink(self):
             return ifile(path.path.readlink(self))
 
         def readlinkabs(self):
             return ifile(path.path.readlinkabs(self))
 
     def getmode(self):
         return self.stat().st_mode
     mode = property(getmode, None, None, "Access mode")
 
     def gettype(self):
         data = [
             (stat.S_ISREG, "file"),
             (stat.S_ISDIR, "dir"),
             (stat.S_ISCHR, "chardev"),
             (stat.S_ISBLK, "blockdev"),
             (stat.S_ISFIFO, "fifo"),
             (stat.S_ISLNK, "symlink"),
             (stat.S_ISSOCK,"socket"),
         ]
         lstat = self.lstat()
         if lstat is not None:
             types = set([text for (func, text) in data if func(lstat.st_mode)])
         else:
             types = set()
         m = self.mode
         types.update([text for (func, text) in data if func(m)])
         return ", ".join(types)
     type = property(gettype, None, None, "file type (file, directory, link, etc.)")
 
     def getmodestr(self):
         m = self.mode
         data = [
             (stat.S_IRUSR, "-r"),
             (stat.S_IWUSR, "-w"),
             (stat.S_IXUSR, "-x"),
             (stat.S_IRGRP, "-r"),
             (stat.S_IWGRP, "-w"),
             (stat.S_IXGRP, "-x"),
             (stat.S_IROTH, "-r"),
             (stat.S_IWOTH, "-w"),
             (stat.S_IXOTH, "-x"),
         ]
         return "".join([text[bool(m&bit)] for (bit, text) in data])
 
     modestr = property(getmodestr, None, None, "Access mode as string")
 
     def getblocks(self):
         return self.stat().st_blocks
     blocks = property(getblocks, None, None, "File size in blocks")
 
     def getblksize(self):
         return self.stat().st_blksize
     blksize = property(getblksize, None, None, "Filesystem block size")
 
     def getdev(self):
         return self.stat().st_dev
     dev = property(getdev)
 
     def getnlink(self):
         return self.stat().st_nlink
     nlink = property(getnlink, None, None, "Number of links")
 
     def getuid(self):
         return self.stat().st_uid
     uid = property(getuid, None, None, "User id of file owner")
 
     def getgid(self):
         return self.stat().st_gid
     gid = property(getgid, None, None, "Group id of file owner")
 
     def getowner(self):
         stat = self.stat()
         try:
             return pwd.getpwuid(stat.st_uid).pw_name
         except KeyError:
             return stat.st_uid
     owner = property(getowner, None, None, "Owner name (or id)")
 
     def getgroup(self):
         stat = self.stat()
         try:
             return grp.getgrgid(stat.st_gid).gr_name
         except KeyError:
             return stat.st_gid
     group = property(getgroup, None, None, "Group name (or id)")
 
     def getadate(self):
         return datetime.datetime.utcfromtimestamp(self.atime)
     adate = property(getadate, None, None, "Access date")
 
     def getcdate(self):
         return datetime.datetime.utcfromtimestamp(self.ctime)
     cdate = property(getcdate, None, None, "Creation date")
 
     def getmdate(self):
         return datetime.datetime.utcfromtimestamp(self.mtime)
     mdate = property(getmdate, None, None, "Modification date")
 
     def getmimetype(self):
         return mimetypes.guess_type(self.basename())[0]
     mimetype = property(getmimetype, None, None, "MIME type")
 
     def getencoding(self):
         return mimetypes.guess_type(self.basename())[1]
     encoding = property(getencoding, None, None, "Compression")
 
     def __repr__(self):
         return "ifile(%s)" % path._base.__repr__(self)
 
     defaultattrs = (None, "type", "size", "modestr", "owner", "group", "mdate")
 
     def __xattrs__(self, mode):
         if mode == "detail":
             return (
                 "name", "basename()", "abspath()", "realpath()",
                 "type", "mode", "modestr", "stat()", "lstat()",
                 "uid", "gid", "owner", "group", "dev", "nlink",
                 "ctime", "mtime", "atime", "cdate", "mdate", "adate",
                 "size", "blocks", "blksize", "isdir()", "islink()",
                 "mimetype", "encoding"
             )
         return self.defaultattrs
 
     def __xrepr__(self, mode):
         yield (-1, True)
         try:
             if self.isdir():
                 name = "idir"
                 style = astyle.style_dir
             else:
                 name = "ifile"
                 style = astyle.style_file
         except IOError:
             name = "ifile"
             style = astyle.style_default
         if mode == "cell" or mode in "header" or mode == "footer":
             abspath = repr(path._base(self.normpath()))
             if abspath.startswith("u"):
                 abspath = abspath[2:-1]
             else:
                 abspath = abspath[1:-1]
             if mode == "cell":
                 yield (style, abspath)
             else:
                 yield (style, "%s(%s)" % (name, abspath))
         else:
             yield (style, repr(self))
 
     def __xiter__(self, mode):
         if self.isdir():
             yield iparentdir(self / os.pardir)
             for child in sorted(self.listdir()):
                 yield child
         else:
             f = self.open("rb")
             for line in f:
                 yield line
             f.close()
 
 
 class iparentdir(ifile):
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "cell":
             yield (astyle.style_dir, os.pardir)
         else:
             for part in ifile.__xrepr__(self, mode):
                 yield part
 
 
 class ils(Table):
     """
     List the current (or a specific) directory.
 
     Examples:
 
         >>> ils
         >>> ils("/usr/local/lib/python2.4")
         >>> ils("~")
     """
     def __init__(self, base=os.curdir):
         self.base = os.path.expanduser(base)
 
     def __xiter__(self, mode):
         return xiter(ifile(self.base), mode)
 
     def __xrepr__(self, mode):
        return ifile(self.base).__xrepr__(mode)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.base)
 
 
 class iglob(Table):
     """
     List all files and directories matching a specified pattern.
     (See ``glob.glob()`` for more info.).
 
     Examples:
 
         >>> iglob("*.py")
     """
     def __init__(self, glob):
         self.glob = glob
 
     def __xiter__(self, mode):
         for name in glob.glob(self.glob):
             yield ifile(name)
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer" or mode == "cell":
             yield (astyle.style_default,
                    "%s(%r)" % (self.__class__.__name__, self.glob))
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.glob)
 
 
 class iwalk(Table):
     """
     List all files and directories in a directory and it's subdirectory.
 
         >>> iwalk
         >>> iwalk("/usr/local/lib/python2.4")
         >>> iwalk("~")
     """
     def __init__(self, base=os.curdir, dirs=True, files=True):
         self.base = os.path.expanduser(base)
         self.dirs = dirs
         self.files = files
 
     def __xiter__(self, mode):
         for (dirpath, dirnames, filenames) in os.walk(self.base):
             if self.dirs:
                 for name in sorted(dirnames):
                     yield ifile(os.path.join(dirpath, name))
             if self.files:
                 for name in sorted(filenames):
                     yield ifile(os.path.join(dirpath, name))
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer" or mode == "cell":
             yield (astyle.style_default,
                    "%s(%r)" % (self.__class__.__name__, self.base))
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.base)
 
 
 class ipwdentry(object):
     """
     ``ipwdentry`` objects encapsulate entries in the Unix user account and
     password database.
     """
     def __init__(self, id):
         self._id = id
         self._entry = None
 
     def _getentry(self):
         if self._entry is None:
             if isinstance(self._id, basestring):
                 self._entry = pwd.getpwnam(self._id)
             else:
                 self._entry = pwd.getpwuid(self._id)
         return self._entry
 
     def getname(self):
         if isinstance(self._id, basestring):
             return self._id
         else:
             return self._getentry().pw_name
     name = property(getname, None, None, "User name")
 
     def getpasswd(self):
         return self._getentry().pw_passwd
     passwd = property(getpasswd, None, None, "Password")
 
     def getuid(self):
         if isinstance(self._id, basestring):
             return self._getentry().pw_uid
         else:
             return self._id
     uid = property(getuid, None, None, "User id")
 
     def getgid(self):
         return self._getentry().pw_gid
     gid = property(getgid, None, None, "Primary group id")
 
     def getgroup(self):
         return igrpentry(self.gid)
     group = property(getgroup, None, None, "Group")
 
     def getgecos(self):
         return self._getentry().pw_gecos
     gecos = property(getgecos, None, None, "Information (e.g. full user name)")
 
     def getdir(self):
         return self._getentry().pw_dir
     dir = property(getdir, None, None, "$HOME directory")
 
     def getshell(self):
         return self._getentry().pw_shell
     shell = property(getshell, None, None, "Login shell")
 
     def __xattrs__(self, mode):
         return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self._id)
 
 
 class ipwd(Table):
     """
     List all entries in the Unix user account and password database.
 
     Example:
 
         >>> ipwd | isort("uid")
     """
     def __iter__(self):
         for entry in pwd.getpwall():
             yield ipwdentry(entry.pw_name)
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer" or mode == "cell":
             yield (astyle.style_default, "%s()" % self.__class__.__name__)
         else:
             yield (astyle.style_default, repr(self))
 
 
 class igrpentry(object):
     """
     ``igrpentry`` objects encapsulate entries in the Unix group database.
     """
     def __init__(self, id):
         self._id = id
         self._entry = None
 
     def _getentry(self):
         if self._entry is None:
             if isinstance(self._id, basestring):
                 self._entry = grp.getgrnam(self._id)
             else:
                 self._entry = grp.getgrgid(self._id)
         return self._entry
 
     def getname(self):
         if isinstance(self._id, basestring):
             return self._id
         else:
             return self._getentry().gr_name
     name = property(getname, None, None, "Group name")
 
     def getpasswd(self):
         return self._getentry().gr_passwd
     passwd = property(getpasswd, None, None, "Password")
 
     def getgid(self):
         if isinstance(self._id, basestring):
             return self._getentry().gr_gid
         else:
             return self._id
     gid = property(getgid, None, None, "Group id")
 
     def getmem(self):
         return self._getentry().gr_mem
     mem = property(getmem, None, None, "Members")
 
     def __xattrs__(self, mode):
         return ("name", "passwd", "gid", "mem")
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer" or mode == "cell":
             yield (astyle.style_default, "group ")
             try:
                 yield (astyle.style_default, self.name)
             except KeyError:
                 if isinstance(self._id, basestring):
                     yield (astyle.style_default, self.name_id)
                 else:
                     yield (astyle.style_type_number, str(self._id))
         else:
             yield (astyle.style_default, repr(self))
 
     def __xiter__(self, mode):
         for member in self.mem:
             yield ipwdentry(member)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self._id)
 
 
 class igrp(Table):
     """
     This ``Table`` lists all entries in the Unix group database.
     """
     def __xiter__(self, mode):
         for entry in grp.getgrall():
             yield igrpentry(entry.gr_name)
 
     def __xrepr__(self, mode):
         yield (-1, False)
         if mode == "header" or mode == "footer":
             yield (astyle.style_default, "%s()" % self.__class__.__name__)
         else:
             yield (astyle.style_default, repr(self))
 
 
 class Fields(object):
     def __init__(self, fieldnames, **fields):
         self.__fieldnames = fieldnames
         for (key, value) in fields.iteritems():
             setattr(self, key, value)
 
     def __xattrs__(self, mode):
         return self.__fieldnames
 
     def __xrepr__(self, mode):
         yield (-1, False)
         if mode == "header" or mode == "cell":
             yield (astyle.style_default, self.__class__.__name__)
             yield (astyle.style_default, "(")
             for (i, f) in enumerate(self.__fieldnames):
                 if i:
                     yield (astyle.style_default, ", ")
                 yield (astyle.style_default, f)
                 yield (astyle.style_default, "=")
                 for part in xrepr(getattr(self, f), "default"):
                     yield part
             yield (astyle.style_default, ")")
         elif mode == "footer":
             yield (astyle.style_default, self.__class__.__name__)
             yield (astyle.style_default, "(")
             for (i, f) in enumerate(self.__fieldnames):
                 if i:
                     yield (astyle.style_default, ", ")
                 yield (astyle.style_default, f)
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
 
 class FieldTable(Table, list):
     def __init__(self, *fields):
         Table.__init__(self)
         list.__init__(self)
         self.fields = fields
 
     def add(self, **fields):
         self.append(Fields(self.fields, **fields))
 
     def __xiter__(self, mode):
         return list.__iter__(self)
 
     def __xrepr__(self, mode):
         yield (-1, False)
         if mode == "header" or mode == "footer":
             yield (astyle.style_default, self.__class__.__name__)
             yield (astyle.style_default, "(")
             for (i, f) in enumerate(self.__fieldnames):
                 if i:
                     yield (astyle.style_default, ", ")
                 yield (astyle.style_default, f)
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "<%s.%s object with fields=%r at 0x%x>" % \
             (self.__class__.__module__, self.__class__.__name__,
              ", ".join(map(repr, self.fields)), id(self))
 
 
 class List(list):
     def __xattrs__(self, mode):
         return xrange(len(self))
 
     def __xrepr__(self, mode):
         yield (-1, False)
         if mode == "header" or mode == "cell" or mode == "footer" or mode == "default":
             yield (astyle.style_default, self.__class__.__name__)
             yield (astyle.style_default, "(")
             for (i, item) in enumerate(self):
                 if i:
                     yield (astyle.style_default, ", ")
                 for part in xrepr(item, "default"):
                     yield part
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
 
 class ienv(Table):
     """
     List environment variables.
 
     Example:
 
         >>> ienv
     """
 
     def __xiter__(self, mode):
         fields = ("key", "value")
         for (key, value) in os.environ.iteritems():
             yield Fields(fields, key=key, value=value)
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "cell":
             yield (astyle.style_default, "%s()" % self.__class__.__name__)
         else:
             yield (astyle.style_default, repr(self))
 
 
 class icsv(Pipe):
     """
     This ``Pipe`` lists turn the input (with must be a pipe outputting lines
     or an ``ifile``) into lines of CVS columns.
     """
     def __init__(self, **csvargs):
         """
         Create an ``icsv`` object. ``cvsargs`` will be passed through as
         keyword arguments to ``cvs.reader()``.
         """
         self.csvargs = csvargs
 
     def __xiter__(self, mode):
         input = self.input
         if isinstance(input, ifile):
             input = input.open("rb")
         reader = csv.reader(input, **self.csvargs)
         for line in reader:
             yield List(line)
 
     def __xrepr__(self, mode):
         yield (-1, False)
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 for part in xrepr(input, mode):
                     yield part
                 yield (astyle.style_default, " | ")
             yield (astyle.style_default, "%s(" % self.__class__.__name__)
             for (i, (name, value)) in enumerate(self.csvargs.iteritems()):
                 if i:
                     yield (astyle.style_default, ", ")
                 yield (astyle.style_default, name)
                 yield (astyle.style_default, "=")
                 for part in xrepr(value, "default"):
                     yield part
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
         return "<%s.%s %s at 0x%x>" % \
         (self.__class__.__module__, self.__class__.__name__, args, id(self))
 
 
 class ix(Table):
     """
     Execute a system command and list its output as lines
     (similar to ``os.popen()``).
 
     Examples:
 
         >>> ix("ps x")
         >>> ix("find .") | ifile
     """
     def __init__(self, cmd):
         self.cmd = cmd
         self._pipe = None
 
     def __xiter__(self, mode):
         self._pipe = os.popen(self.cmd)
         for l in self._pipe:
             yield l.rstrip("\r\n")
         self._pipe.close()
         self._pipe = None
 
     def __del__(self):
         if self._pipe is not None and not self._pipe.closed:
             self._pipe.close()
         self._pipe = None
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             yield (astyle.style_default,
                    "%s(%r)" % (self.__class__.__name__, self.cmd))
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.cmd)
 
 
 class ifilter(Pipe):
     """
     Filter an input pipe. Only objects where an expression evaluates to true
     (and doesn't raise an exception) are listed.
 
     Examples:
 
         >>> ils | ifilter("_.isfile() and size>1000")
         >>> igrp | ifilter("len(mem)")
         >>> sys.modules | ifilter(lambda _:_.value is not None)
     """
 
     def __init__(self, expr, errors="raiseifallfail"):
         """
         Create an ``ifilter`` object. ``expr`` can be a callable or a string
         containing an expression. ``errors`` specifies how exception during
         evaluation of ``expr`` are handled:
 
         * ``drop``: drop all items that have errors;
 
         * ``keep``: keep all items that have errors;
 
         * ``keeperror``: keep the exception of all items that have errors;
 
         * ``raise``: raise the exception;
 
         * ``raiseifallfail``: raise the first exception if all items have errors;
           otherwise drop those with errors (this is the default).
         """
         self.expr = expr
         self.errors = errors
 
     def __xiter__(self, mode):
         if callable(self.expr):
             def test(item):
                 return self.expr(item)
         else:
             def test(item):
-                return eval(self.expr, globals(), _AttrNamespace(item))
+                return eval(self.expr, globals(), AttrNamespace(item))
 
         ok = 0
         exc_info = None
         for item in xiter(self.input, mode):
             try:
                 if test(item):
                     yield item
                 ok += 1
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception, exc:
                 if self.errors == "drop":
                     pass # Ignore errors
                 elif self.errors == "keep":
                     yield item
                 elif self.errors == "keeperror":
                     yield exc
                 elif self.errors == "raise":
                     raise
                 elif self.errors == "raiseifallfail":
                     if exc_info is None:
                         exc_info = sys.exc_info()
         if not ok and exc_info is not None:
             raise exc_info[0], exc_info[1], exc_info[2]
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 for part in xrepr(input, mode):
                     yield part
                 yield (astyle.style_default, " | ")
             yield (astyle.style_default, "%s(" % self.__class__.__name__)
             for part in xrepr(self.expr, "default"):
                 yield part
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "<%s.%s expr=%r at 0x%x>" % \
             (self.__class__.__module__, self.__class__.__name__,
              self.expr, id(self))
 
 
 class ieval(Pipe):
     """
     Evaluate an expression for each object in the input pipe.
 
     Examples:
 
         >>> ils | ieval("_.abspath()")
         >>> sys.path | ieval(ifile)
     """
 
     def __init__(self, expr, errors="raiseifallfail"):
         """
         Create an ``ieval`` object. ``expr`` can be a callable or a string
         containing an expression. For the meaning of ``errors`` see ``ifilter``.
         """
         self.expr = expr
         self.errors = errors
 
     def __xiter__(self, mode):
         if callable(self.expr):
             def do(item):
                 return self.expr(item)
         else:
             def do(item):
-                return eval(self.expr, globals(), _AttrNamespace(item))
+                return eval(self.expr, globals(), AttrNamespace(item))
 
         ok = 0
         exc_info = None
         for item in xiter(self.input, mode):
             try:
                 yield do(item)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception, exc:
                 if self.errors == "drop":
                     pass # Ignore errors
                 elif self.errors == "keep":
                     yield item
                 elif self.errors == "keeperror":
                     yield exc
                 elif self.errors == "raise":
                     raise
                 elif self.errors == "raiseifallfail":
                     if exc_info is None:
                         exc_info = sys.exc_info()
         if not ok and exc_info is not None:
             raise exc_info[0], exc_info[1], exc_info[2]
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 for part in xrepr(input, mode):
                     yield part
                 yield (astyle.style_default, " | ")
             yield (astyle.style_default, "%s(" % self.__class__.__name__)
             for part in xrepr(self.expr, "default"):
                 yield part
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "<%s.%s expr=%r at 0x%x>" % \
             (self.__class__.__module__, self.__class__.__name__,
              self.expr, id(self))
 
 
 class ienum(Pipe):
     """
     Enumerate the input pipe (i.e. wrap each input object in an object
     with ``index`` and ``object`` attributes).
 
     Examples:
 
         >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
     """
     def __xiter__(self, mode):
         fields = ("index", "object")
         for (index, object) in enumerate(xiter(self.input, mode)):
             yield Fields(fields, index=index, object=object)
 
 
 class isort(Pipe):
     """
     Sorts the input pipe.
 
     Examples:
 
         >>> ils | isort("size")
         >>> ils | isort("_.isdir(), _.lower()", reverse=True)
     """
 
     def __init__(self, key, reverse=False):
         """
         Create an ``isort`` object. ``key`` can be a callable or a string
         containing an expression. If ``reverse`` is true the sort order will
         be reversed.
         """
         self.key = key
         self.reverse = reverse
 
     def __xiter__(self, mode):
         if callable(self.key):
             items = sorted(
                 xiter(self.input, mode),
                 key=self.key,
                 reverse=self.reverse
             )
         else:
             def key(item):
-                return eval(self.key, globals(), _AttrNamespace(item))
+                return eval(self.key, globals(), AttrNamespace(item))
             items = sorted(
                 xiter(self.input, mode),
                 key=key,
                 reverse=self.reverse
             )
         for item in items:
             yield item
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 for part in xrepr(input, mode):
                     yield part
                 yield (astyle.style_default, " | ")
             yield (astyle.style_default, "%s(" % self.__class__.__name__)
             for part in xrepr(self.key, "default"):
                 yield part
             if self.reverse:
                 yield (astyle.style_default, ", ")
                 for part in xrepr(True, "default"):
                     yield part
             yield (astyle.style_default, ")")
         else:
             yield (astyle.style_default, repr(self))
 
     def __repr__(self):
         return "<%s.%s key=%r reverse=%r at 0x%x>" % \
             (self.__class__.__module__, self.__class__.__name__,
              self.key, self.reverse, id(self))
 
 
 tab = 3 # for expandtabs()
 
 def _format(field):
     if isinstance(field, str):
         text = repr(field.expandtabs(tab))[1:-1]
     elif isinstance(field, unicode):
         text = repr(field.expandtabs(tab))[2:-1]
     elif isinstance(field, datetime.datetime):
         # Don't use strftime() here, as this requires year >= 1900
         text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
             (field.year, field.month, field.day,
              field.hour, field.minute, field.second, field.microsecond)
     elif isinstance(field, datetime.date):
         text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
     else:
         text = repr(field)
     return text
 
 
 class Display(object):
     class __metaclass__(type):
         def __ror__(self, input):
             return input | self()
 
     def __ror__(self, input):
         self.input = input
         return self
 
     def display(self):
         pass
 
 
 class iless(Display):
     cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
 
     def display(self):
         try:
             pager = os.popen(self.cmd, "w")
             try:
                 for item in xiter(self.input, "default"):
                     attrs = xattrs(item, "default")
                     attrs = ["%s=%s" % (a, _format(_getattr(item, a))) for a in attrs]
                     pager.write(" ".join(attrs))
                     pager.write("\n")
             finally:
                 pager.close()
         except Exception, exc:
             print "%s: %s" % (exc.__class__.__name__, str(exc))
 
 
 def xformat(value, mode, maxlength):
     align = None
     full = False
     width = 0
     text = astyle.Text()
     for part in xrepr(value, mode):
         # part is (alignment, stop)
         if isinstance(part[0], int):
             # only consider the first occurence
             if align is None:
                 align = part[0]
                 full = part[1]
         # part is (style, text)
         else:
             text.append(part)
             width += len(part[1])
             if width >= maxlength and not full:
                 text.append((astyle.style_ellisis, "..."))
                 width += 3
                 break
     if align is None: # default to left alignment
         align = -1
     return (align, width, text)
 
 
 class idump(Display):
     # The approximate maximum length of a column entry
     maxattrlength = 200
 
     # Style for column names
     style_header = astyle.Style.fromstr("white:black:bold")
 
     def __init__(self, *attrs):
         self.attrs = attrs
         self.headerpadchar = " "
         self.headersepchar = "|"
         self.datapadchar = " "
         self.datasepchar = "|"
 
     def display(self):
         stream = genutils.Term.cout
         allattrs = []
         allattrset = set()
         colwidths = {}
         rows = []
         for item in xiter(self.input, "default"):
             row = {}
             attrs = self.attrs
             if not attrs:
                 attrs = xattrs(item, "default")
             for attrname in attrs:
                 if attrname not in allattrset:
                     allattrs.append(attrname)
                     allattrset.add(attrname)
                     colwidths[attrname] = len(_attrname(attrname))
                 try:
                     value = _getattr(item, attrname, None)
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     value = exc
                 (align, width, text) = xformat(value, "cell", self.maxattrlength)
                 colwidths[attrname] = max(colwidths[attrname], width)
                 # remember alignment, length and colored parts
                 row[attrname] = (align, width, text)
             rows.append(row)
 
         stream.write("\n")
         for (i, attrname) in enumerate(allattrs):
             self.style_header(_attrname(attrname)).write(stream)
             spc = colwidths[attrname] - len(_attrname(attrname))
             if i < len(colwidths)-1:
                 stream.write(self.headerpadchar*spc)
                 stream.write(self.headersepchar)
         stream.write("\n")
 
         for row in rows:
             for (i, attrname) in enumerate(allattrs):
                 (align, width, text) = row[attrname]
                 spc = colwidths[attrname] - width
                 if align == -1:
                     text.write(stream)
                     if i < len(colwidths)-1:
                         stream.write(self.datapadchar*spc)
                 elif align == 0:
                     spc = colwidths[attrname] - width
                     spc1 = spc//2
                     spc2 = spc-spc1
                     stream.write(self.datapadchar*spc1)
                     text.write(stream)
                     if i < len(colwidths)-1:
                         stream.write(self.datapadchar*spc2)
                 else:
                     stream.write(self.datapadchar*spc)
                     text.write(stream)
                 if i < len(colwidths)-1:
                     stream.write(self.datasepchar)
             stream.write("\n")
 
 
 class XMode(object):
     """
     An ``XMode`` object describes one enter mode available for an object
     """
     def __init__(self, object, mode, title=None, description=None):
         """
         Create a new ``XMode`` object for the object ``object``. This object
         must support the enter mode ``mode`` (i.e. ``object.__xiter__(mode)``
         must return an iterable). ``title`` and ``description`` will be
         displayed in the browser when selecting among the available modes.
         """
         self.object = object
         self.mode = mode
         self.title = title
         self.description = description
 
     def __repr__(self):
         return "<%s.%s object mode=%r at 0x%x>" % \
             (self.__class__.__module__, self.__class__.__name__,
              self.mode, id(self))
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             yield (astyle.style_default, self.title)
         else:
             yield (astyle.style_default, repr(self))
 
     def __xattrs__(self, mode):
         if mode == "detail":
             return ("object", "mode", "title", "description")
         return ("title", "description")
 
     def __xiter__(self, mode):
         return xiter(self.object, self.mode)
 
 
 class XAttr(object):
     def __init__(self, object, name):
         self.name = _attrname(name)
 
         try:
             self.value = _getattr(object, name)
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception, exc:
             if exc.__class__.__module__ == "exceptions":
                 self.value = exc.__class__.__name__
             else:
                 self.value = "%s.%s" % \
                     (exc.__class__.__module__, exc.__class__.__name__)
             self.type = self.value
         else:
             t = type(self.value)
             if t.__module__ == "__builtin__":
                 self.type = t.__name__
             else:
                 self.type = "%s.%s" % (t.__module__, t.__name__)
 
         doc = None
         if isinstance(name, basestring):
             if name.endswith("()"):
                 doc = getattr(getattr(object, name[:-2]), "__doc__", None)
             else:
                 try:
                     meta = getattr(type(object), name)
                 except AttributeError:
                     pass
                 else:
                     if isinstance(meta, property):
                         doc = getattr(meta, "__doc__", None)
         elif callable(name):
             doc = getattr(name, "__doc__", None)
         if isinstance(doc, basestring):
             doc = doc.strip()
         self.doc = doc
 
     def __xattrs__(self, mode):
         return ("name", "type", "doc", "value")
 
 
-_ibrowse_help = """
-down
-Move the cursor to the next line.
-
-up
-Move the cursor to the previous line.
-
-pagedown
-Move the cursor down one page (minus overlap).
-
-pageup
-Move the cursor up one page (minus overlap).
-
-left
-Move the cursor left.
-
-right
-Move the cursor right.
-
-home
-Move the cursor to the first column.
-
-end
-Move the cursor to the last column.
-
-prevattr
-Move the cursor one attribute column to the left.
-
-nextattr
-Move the cursor one attribute column to the right.
-
-pick
-'Pick' the object under the cursor (i.e. the row the cursor is on). This
-leaves the browser and returns the picked object to the caller. (In IPython
-this object will be available as the '_' variable.)
-
-pickattr
-'Pick' the attribute under the cursor (i.e. the row/column the cursor is on).
-
-pickallattrs
-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.
-
-tooglemark
-Mark/unmark the object under the cursor. Marked objects have a '!' after the
-row number).
-
-pickmarked
-'Pick' marked objects. Marked objects will be returned as a list.
-
-pickmarkedattr
-'Pick' the attribute under the cursor from all marked objects (This returns a
-list).
-
-enterdefault
-Enter the object under the cursor. (what this mean depends on the object
-itself (i.e. how it implements the '__xiter__' method). This opens a new
-browser 'level'.
-
-enter
-Enter the object under the cursor. If the object provides different enter
-modes a menu of all modes will be presented; choose one and enter it (via the
-'enter' or 'enterdefault' command).
-
-enterattr
-Enter the attribute under the cursor.
-
-leave
-Leave the current browser level and go back to the previous one.
-
-detail
-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).
-
-detailattr
-Show a detail view of the attribute under the cursor.
-
-markrange
-Mark all objects from the last marked object before the current cursor
-position to the cursor position.
-
-sortattrasc
-Sort the objects (in ascending order) using the attribute under the cursor as
-the sort key.
-
-sortattrdesc
-Sort the objects (in descending order) using the attribute under the cursor as
-the sort key.
-
-goto
-Jump to a row. The row number can be entered at the bottom of the screen.
-
-find
-Search forward for a row. At the bottom of the screen the condition can be
-entered.
-
-findbackwards
-Search backward for a row. At the bottom of the screen the condition can be
-entered.
-
-help
-This screen.
-"""
-
-
-if curses is not None:
-    class UnassignedKeyError(Exception):
-        """
-        Exception that is used for reporting unassigned keys.
-        """
-
-
-    class UnknownCommandError(Exception):
-        """
-        Exception that is used for reporting unknown command (this should never
-        happen).
-        """
-
-
-    class CommandError(Exception):
-        """
-        Exception that is used for reporting that a command can't be executed.
-        """
-
-
-    class _BrowserCachedItem(object):
-        # This is used internally by ``ibrowse`` to store a item together with its
-        # marked status.
-        __slots__ = ("item", "marked")
-
-        def __init__(self, item):
-            self.item = item
-            self.marked = False
-
-
-    class _BrowserHelp(object):
-        style_header = astyle.Style.fromstr("red:blacK")
-        # This is used internally by ``ibrowse`` for displaying the help screen.
-        def __init__(self, browser):
-            self.browser = browser
-
-        def __xrepr__(self, mode):
-            yield (-1, True)
-            if mode == "header" or mode == "footer":
-                yield (astyle.style_default, "ibrowse help screen")
-            else:
-                yield (astyle.style_default, repr(self))
-
-        def __xiter__(self, mode):
-            # Get reverse key mapping
-            allkeys = {}
-            for (key, cmd) in self.browser.keymap.iteritems():
-                allkeys.setdefault(cmd, []).append(key)
-
-            fields = ("key", "description")
-
-            for (i, command) in enumerate(_ibrowse_help.strip().split("\n\n")):
-                if i:
-                    yield Fields(fields, key="", description="")
-
-                (name, description) = command.split("\n", 1)
-                keys = allkeys.get(name, [])
-                lines = textwrap.wrap(description, 60)
-
-                yield Fields(fields, description=astyle.Text((self.style_header, name)))
-                for i in xrange(max(len(keys), len(lines))):
-                    try:
-                        key = self.browser.keylabel(keys[i])
-                    except IndexError:
-                        key = ""
-                    try:
-                        line = lines[i]
-                    except IndexError:
-                        line = ""
-                    yield Fields(fields, key=key, description=line)
-
-
-    class _BrowserLevel(object):
-        # This is used internally to store the state (iterator, fetch items,
-        # position of cursor and screen, etc.) of one browser level
-        # An ``ibrowse`` object keeps multiple ``_BrowserLevel`` objects in
-        # a stack.
-        def __init__(self, browser, input, iterator, mainsizey, *attrs):
-            self.browser = browser
-            self.input = input
-            self.header = [x for x in xrepr(input, "header") if not isinstance(x[0], int)]
-            # iterator for the input
-            self.iterator = iterator
-
-            # is the iterator exhausted?
-            self.exhausted = False
-
-            # attributes to be display (autodetected if empty)
-            self.attrs = attrs
-
-            # fetched items (+ marked flag)
-            self.items = deque()
-
-            # Number of marked objects
-            self.marked = 0
-
-            # Vertical cursor position
-            self.cury = 0
-
-            # Horizontal cursor position
-            self.curx = 0
-
-            # Index of first data column
-            self.datastartx = 0
-
-            # Index of first data line
-            self.datastarty = 0
-
-            # height of the data display area
-            self.mainsizey = mainsizey
-
-            # width of the data display area (changes when scrolling)
-            self.mainsizex = 0
-
-            # Size of row number (changes when scrolling)
-            self.numbersizex = 0
-
-            # Attribute names to display (in this order)
-            self.displayattrs = []
-
-            # index and name of attribute under the cursor
-            self.displayattr = (None, _default)
-
-            # Maps attribute names to column widths
-            self.colwidths = {}
-
-            self.fetch(mainsizey)
-            self.calcdisplayattrs()
-            # formatted attributes for the items on screen
-            # (i.e. self.items[self.datastarty:self.datastarty+self.mainsizey])
-            self.displayrows = [self.getrow(i) for i in xrange(len(self.items))]
-            self.calcwidths()
-            self.calcdisplayattr()
-
-        def fetch(self, count):
-            # Try to fill ``self.items`` with at least ``count`` objects.
-            have = len(self.items)
-            while not self.exhausted and have < count:
-                try:
-                    item = self.iterator.next()
-                except StopIteration:
-                    self.exhausted = True
-                    break
-                else:
-                    have += 1
-                    self.items.append(_BrowserCachedItem(item))
-
-        def calcdisplayattrs(self):
-            # Calculate which attributes are available from the objects that are
-            # currently visible on screen (and store it in ``self.displayattrs``)
-            attrnames = set()
-            # If the browser object specifies a fixed list of attributes,
-            # simply use it.
-            if self.attrs:
-                self.displayattrs = self.attrs
-            else:
-                self.displayattrs = []
-                endy = min(self.datastarty+self.mainsizey, len(self.items))
-                for i in xrange(self.datastarty, endy):
-                    for attrname in xattrs(self.items[i].item, "default"):
-                        if attrname not in attrnames:
-                            self.displayattrs.append(attrname)
-                            attrnames.add(attrname)
-
-        def getrow(self, i):
-            # Return a dictinary with the attributes for the object
-            # ``self.items[i]``. Attribute names are taken from
-            # ``self.displayattrs`` so ``calcdisplayattrs()`` must have been
-            # called before.
-            row = {}
-            item = self.items[i].item
-            for attrname in self.displayattrs:
-                try:
-                    value = _getattr(item, attrname, _default)
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception, exc:
-                    value = exc
-                # only store attribute if it exists (or we got an exception)
-                if value is not _default:
-                    parts = []
-                    totallength = 0
-                    align = None
-                    full = False
-                    # Collect parts until we have enough
-                    for part in xrepr(value, "cell"):
-                        # part gives (alignment, stop)
-                        # instead of (style, text)
-                        if isinstance(part[0], int):
-                            # only consider the first occurence
-                            if align is None:
-                                align = part[0]
-                                full = part[1]
-                        else:
-                            parts.append(part)
-                            totallength += len(part[1])
-                            if totallength >= self.browser.maxattrlength and not full:
-                                parts.append((astyle.style_ellisis, "..."))
-                                totallength += 3
-                                break
-                    # remember alignment, length and colored parts
-                    row[attrname] = (align, totallength, parts)
-            return row
-
-        def calcwidths(self):
-            # Recalculate the displayed fields and their width.
-            # ``calcdisplayattrs()'' must have been called and the cache
-            # for attributes of the objects on screen (``self.displayrows``)
-            # must have been filled. This returns a dictionary mapping
-            # colmn names to width.
-            self.colwidths = {}
-            for row in self.displayrows:
-                for attrname in self.displayattrs:
-                    try:
-                        length = row[attrname][1]
-                    except KeyError:
-                        length = 0
-                    # always add attribute to colwidths, even if it doesn't exist
-                    if attrname not in self.colwidths:
-                        self.colwidths[attrname] = len(_attrname(attrname))
-                    newwidth = max(self.colwidths[attrname], length)
-                    self.colwidths[attrname] = newwidth
-
-            # How many characters do we need to paint the item number?
-            self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
-            # How must space have we got to display data?
-            self.mainsizex = self.browser.scrsizex-self.numbersizex-3
-            # width of all columns
-            self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
-
-        def calcdisplayattr(self):
-            # Find out on which attribute the cursor is on and store this
-            # information in ``self.displayattr``.
-            pos = 0
-            for (i, attrname) in enumerate(self.displayattrs):
-                if pos+self.colwidths[attrname] >= self.curx:
-                    self.displayattr = (i, attrname)
-                    break
-                pos += self.colwidths[attrname]+1
-            else:
-                self.displayattr = (None, _default)
-
-        def moveto(self, x, y, refresh=False):
-            # Move the cursor to the position ``(x,y)`` (in data coordinates,
-            # not in screen coordinates). If ``refresh`` is true, all cached
-            # values will be recalculated (e.g. because the list has been
-            # resorted, so screen positions etc. are no longer valid).
-            olddatastarty = self.datastarty
-            oldx = self.curx
-            oldy = self.cury
-            x = int(x+0.5)
-            y = int(y+0.5)
-            newx = x # remember where we wanted to move
-            newy = y # remember where we wanted to move
-
-            scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
-            scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
-
-            # Make sure that the cursor didn't leave the main area vertically
-            if y < 0:
-                y = 0
-            self.fetch(y+scrollbordery+1) # try to get more items
-            if y >= len(self.items):
-                y = max(0, len(self.items)-1)
-
-            # Make sure that the cursor stays on screen vertically
-            if y < self.datastarty+scrollbordery:
-                self.datastarty = max(0, y-scrollbordery)
-            elif y >= self.datastarty+self.mainsizey-scrollbordery:
-                self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
-                                             len(self.items)-self.mainsizey))
-
-            if refresh: # Do we need to refresh the complete display?
-                self.calcdisplayattrs()
-                endy = min(self.datastarty+self.mainsizey, len(self.items))
-                self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
-                self.calcwidths()
-            # Did we scroll vertically => update displayrows
-            # and various other attributes
-            elif self.datastarty != olddatastarty:
-                # Recalculate which attributes we have to display
-                olddisplayattrs = self.displayattrs
-                self.calcdisplayattrs()
-                # If there are new attributes, recreate the cache
-                if self.displayattrs != olddisplayattrs:
-                    endy = min(self.datastarty+self.mainsizey, len(self.items))
-                    self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
-                elif self.datastarty<olddatastarty: # we did scroll up
-                    # drop rows from the end
-                    del self.displayrows[self.datastarty-olddatastarty:]
-                    # fetch new items
-                    for i in xrange(olddatastarty-1,
-                                    self.datastarty-1, -1):
-                        try:
-                            row = self.getrow(i)
-                        except IndexError:
-                            # we didn't have enough objects to fill the screen
-                            break
-                        self.displayrows.insert(0, row)
-                else: # we did scroll down
-                    # drop rows from the start
-                    del self.displayrows[:self.datastarty-olddatastarty]
-                    # fetch new items
-                    for i in xrange(olddatastarty+self.mainsizey,
-                                    self.datastarty+self.mainsizey):
-                        try:
-                            row = self.getrow(i)
-                        except IndexError:
-                            # we didn't have enough objects to fill the screen
-                            break
-                        self.displayrows.append(row)
-                self.calcwidths()
-
-            # Make sure that the cursor didn't leave the data area horizontally
-            if x < 0:
-                x = 0
-            elif x >= self.datasizex:
-                x = max(0, self.datasizex-1)
-
-            # Make sure that the cursor stays on screen horizontally
-            if x < self.datastartx+scrollborderx:
-                self.datastartx = max(0, x-scrollborderx)
-            elif x >= self.datastartx+self.mainsizex-scrollborderx:
-                self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
-                                             self.datasizex-self.mainsizex))
-
-            if x == oldx and y == oldy and (x != newx or y != newy): # couldn't move
-                self.browser.beep()
-            else:
-                self.curx = x
-                self.cury = y
-                self.calcdisplayattr()
-
-        def sort(self, key, reverse=False):
-            """
-            Sort the currently list of items using the key function ``key``. If
-            ``reverse`` is true the sort order is reversed.
-            """
-            curitem = self.items[self.cury] # Remember where the cursor is now
-
-            # Sort items
-            def realkey(item):
-                return key(item.item)
-            self.items = deque(sorted(self.items, key=realkey, reverse=reverse))
-
-            # Find out where the object under the cursor went
-            cury = self.cury
-            for (i, item) in enumerate(self.items):
-                if item is curitem:
-                    cury = i
-                    break
-
-            self.moveto(self.curx, cury, refresh=True)
-
-
-    class ibrowse(Display):
-        # Show this many lines from the previous screen when paging horizontally
-        pageoverlapx = 1
-
-        # Show this many lines from the previous screen when paging vertically
-        pageoverlapy = 1
-
-        # Start scrolling when the cursor is less than this number of columns
-        # away from the left or right screen edge
-        scrollborderx = 10
-
-        # Start scrolling when the cursor is less than this number of lines
-        # away from the top or bottom screen edge
-        scrollbordery = 5
-
-        # Accelerate by this factor when scrolling horizontally
-        acceleratex = 1.05
-
-        # Accelerate by this factor when scrolling vertically
-        acceleratey = 1.05
-
-        # The maximum horizontal scroll speed
-        # (as a factor of the screen width (i.e. 0.5 == half a screen width)
-        maxspeedx = 0.5
-
-        # The maximum vertical scroll speed
-        # (as a factor of the screen height (i.e. 0.5 == half a screen height)
-        maxspeedy = 0.5
-
-        # The maximum number of header lines for browser level
-        # if the nesting is deeper, only the innermost levels are displayed
-        maxheaders = 5
-
-        # The approximate maximum length of a column entry
-        maxattrlength = 200
-
-        # Styles for various parts of the GUI
-        style_objheadertext = astyle.Style.fromstr("white:black:bold|reverse")
-        style_objheadernumber = astyle.Style.fromstr("white:blue:bold|reverse")
-        style_objheaderobject = astyle.Style.fromstr("white:black:reverse")
-        style_colheader = astyle.Style.fromstr("blue:white:reverse")
-        style_colheaderhere = astyle.Style.fromstr("green:black:bold|reverse")
-        style_colheadersep = astyle.Style.fromstr("blue:black:reverse")
-        style_number = astyle.Style.fromstr("blue:white:reverse")
-        style_numberhere = astyle.Style.fromstr("green:black:bold|reverse")
-        style_sep = astyle.Style.fromstr("blue:black")
-        style_data = astyle.Style.fromstr("white:black")
-        style_datapad = astyle.Style.fromstr("blue:black:bold")
-        style_footer = astyle.Style.fromstr("black:white")
-        style_report = astyle.Style.fromstr("white:black")
-
-        # Column separator in header
-        headersepchar = "|"
-
-        # Character for padding data cell entries
-        datapadchar = "."
-
-        # Column separator in data area
-        datasepchar = "|"
-
-        # Character to use for "empty" cell (i.e. for non-existing attributes)
-        nodatachar = "-"
-
-        # Prompts for modes that require keyboard input
-        prompts = {
-            "goto": "goto object #: ",
-            "find": "find expression: ",
-            "findbackwards": "find backwards expression: "
-        }
-
-        # Maps curses key codes to "function" names
-        keymap = {
-            ord("q"): "quit",
-            curses.KEY_UP: "up",
-            curses.KEY_DOWN: "down",
-            curses.KEY_PPAGE: "pageup",
-            curses.KEY_NPAGE: "pagedown",
-            curses.KEY_LEFT: "left",
-            curses.KEY_RIGHT: "right",
-            curses.KEY_HOME: "home",
-            curses.KEY_END: "end",
-            ord("<"): "prevattr",
-            0x1b:     "prevattr", # SHIFT-TAB
-            ord(">"): "nextattr",
-            ord("\t"):"nextattr", # TAB
-            ord("p"): "pick",
-            ord("P"): "pickattr",
-            ord("C"): "pickallattrs",
-            ord("m"): "pickmarked",
-            ord("M"): "pickmarkedattr",
-            ord("\n"): "enterdefault",
-            # FIXME: What's happening here?
-            8: "leave",
-            127: "leave",
-            curses.KEY_BACKSPACE: "leave",
-            ord("x"): "leave",
-            ord("h"): "help",
-            ord("e"): "enter",
-            ord("E"): "enterattr",
-            ord("d"): "detail",
-            ord("D"): "detailattr",
-            ord(" "): "tooglemark",
-            ord("r"): "markrange",
-            ord("v"): "sortattrasc",
-            ord("V"): "sortattrdesc",
-            ord("g"): "goto",
-            ord("f"): "find",
-            ord("b"): "findbackwards",
-        }
-
-        def __init__(self, *attrs):
-            """
-            Create a new browser. If ``attrs`` is not empty, it is the list
-            of attributes that will be displayed in the browser, otherwise
-            these will be determined by the objects on screen.
-            """
-            self.attrs = attrs
-
-            # Stack of browser levels
-            self.levels = []
-            # how many colums to scroll (Changes when accelerating)
-            self.stepx = 1.
-
-            # how many rows to scroll (Changes when accelerating)
-            self.stepy = 1.
-
-            # Beep on the edges of the data area? (Will be set to ``False``
-            # once the cursor hits the edge of the screen, so we don't get
-            # multiple beeps).
-            self._dobeep = True
-
-            # Cache for registered ``curses`` colors and styles.
-            self._styles = {}
-            self._colors = {}
-            self._maxcolor = 1
-
-            # How many header lines do we want to paint (the numbers of levels
-            # we have, but with an upper bound)
-            self._headerlines = 1
-
-            # Index of first header line
-            self._firstheaderline = 0
-
-            # curses window
-            self.scr = None
-            # report in the footer line (error, executed command etc.)
-            self._report = None
-
-            # value to be returned to the caller (set by commands)
-            self.returnvalue = None
-
-            # The mode the browser is in
-            # e.g. normal browsing or entering an argument for a command
-            self.mode = "default"
-
-            # The partially entered row number for the goto command
-            self.goto = ""
-
-        def nextstepx(self, step):
-            """
-            Accelerate horizontally.
-            """
-            return max(1., min(step*self.acceleratex,
-                               self.maxspeedx*self.levels[-1].mainsizex))
-
-        def nextstepy(self, step):
-            """
-            Accelerate vertically.
-            """
-            return max(1., min(step*self.acceleratey,
-                               self.maxspeedy*self.levels[-1].mainsizey))
-
-        def getstyle(self, style):
-            """
-            Register the ``style`` with ``curses`` or get it from the cache,
-            if it has been registered before.
-            """
-            try:
-                return self._styles[style.fg, style.bg, style.attrs]
-            except KeyError:
-                attrs = 0
-                for b in astyle.A2CURSES:
-                    if style.attrs & b:
-                        attrs |= astyle.A2CURSES[b]
                 try:
-                    color = self._colors[style.fg, style.bg]
-                except KeyError:
-                    curses.init_pair(
-                        self._maxcolor,
-                        astyle.COLOR2CURSES[style.fg],
-                        astyle.COLOR2CURSES[style.bg]
-                    )
-                    color = curses.color_pair(self._maxcolor)
-                    self._colors[style.fg, style.bg] = color
-                    self._maxcolor += 1
-                c = color | attrs
-                self._styles[style.fg, style.bg, style.attrs] = c
-                return c
-
-        def addstr(self, y, x, begx, endx, text, style):
-            """
-            A version of ``curses.addstr()`` that can handle ``x`` coordinates
-            that are outside the screen.
-            """
-            text2 = text[max(0, begx-x):max(0, endx-x)]
-            if text2:
-                self.scr.addstr(y, max(x, begx), text2, self.getstyle(style))
-            return len(text)
-
-        def addchr(self, y, x, begx, endx, c, l, style):
-            x0 = max(x, begx)
-            x1 = min(x+l, endx)
-            if x1>x0:
-                self.scr.addstr(y, x0, c*(x1-x0), self.getstyle(style))
-            return l
-
-        def _calcheaderlines(self, levels):
-            # Calculate how many headerlines do we have to display, if we have
-            # ``levels`` browser levels
-            if levels is None:
-                levels = len(self.levels)
-            self._headerlines = min(self.maxheaders, levels)
-            self._firstheaderline = levels-self._headerlines
-
-        def getstylehere(self, style):
-            """
-            Return a style for displaying the original style ``style``
-            in the row the cursor is on.
-            """
-            return astyle.Style(style.fg, style.bg, style.attrs | astyle.A_BOLD)
-
-        def report(self, msg):
-            """
-            Store the message ``msg`` for display below the footer line. This
-            will be displayed as soon as the screen is redrawn.
-            """
-            self._report = msg
-
-        def enter(self, item, mode, *attrs):
-            """
-            Enter the object ``item`` in the mode ``mode``. If ``attrs`` is
-            specified, it will be used as a fixed list of attributes to display.
-            """
-            try:
-                iterator = xiter(item, mode)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                curses.beep()
-                self.report(exc)
-            else:
-                self._calcheaderlines(len(self.levels)+1)
-                level = _BrowserLevel(
-                    self,
-                    item,
-                    iterator,
-                    self.scrsizey-1-self._headerlines-2,
-                    *attrs
-                )
-                self.levels.append(level)
-
-        def startkeyboardinput(self, mode):
-            """
-            Enter mode ``mode``, which requires keyboard input.
-            """
-            self.mode = mode
-            self.keyboardinput = ""
-            self.cursorpos = 0
-
-        def executekeyboardinput(self, mode):
-            exe = getattr(self, "exe_%s" % mode, None)
-            if exe is not None:
-               exe()
-               self.mode = "default"
-
-        def keylabel(self, keycode):
-            """
-            Return a pretty name for the ``curses`` key ``keycode`` (used in the
-            help screen and in reports about unassigned keys).
-            """
-            if keycode <= 0xff:
-                specialsnames = {
-                    ord("\n"): "RETURN",
-                    ord(" "): "SPACE",
-                    ord("\t"): "TAB",
-                    ord("\x7f"): "DELETE",
-                    ord("\x08"): "BACKSPACE",
-                }
-                if keycode in specialsnames:
-                    return specialsnames[keycode]
-                return repr(chr(keycode))
-            for name in dir(curses):
-                if name.startswith("KEY_") and getattr(curses, name) == keycode:
-                    return name
-            return str(keycode)
-
-        def beep(self, force=False):
-            if force or self._dobeep:
-                curses.beep()
-                # don't beep again (as long as the same key is pressed)
-                self._dobeep = False
-
-        def cmd_quit(self):
-            self.returnvalue = None
-            return True
-
-        def cmd_up(self):
-            level = self.levels[-1]
-            self.report("up")
-            level.moveto(level.curx, level.cury-self.stepy)
-
-        def cmd_down(self):
-            level = self.levels[-1]
-            self.report("down")
-            level.moveto(level.curx, level.cury+self.stepy)
-
-        def cmd_pageup(self):
-            level = self.levels[-1]
-            self.report("page up")
-            level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
-
-        def cmd_pagedown(self):
-            level = self.levels[-1]
-            self.report("page down")
-            level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
-
-        def cmd_left(self):
-            level = self.levels[-1]
-            self.report("left")
-            level.moveto(level.curx-self.stepx, level.cury)
-
-        def cmd_right(self):
-            level = self.levels[-1]
-            self.report("right")
-            level.moveto(level.curx+self.stepx, level.cury)
-
-        def cmd_home(self):
-            level = self.levels[-1]
-            self.report("home")
-            level.moveto(0, level.cury)
-
-        def cmd_end(self):
-            level = self.levels[-1]
-            self.report("end")
-            level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
-
-        def cmd_prevattr(self):
-            level = self.levels[-1]
-            if level.displayattr[0] is None or level.displayattr[0] == 0:
-                self.beep()
-            else:
-                self.report("prevattr")
-                pos = 0
-                for (i, attrname) in enumerate(level.displayattrs):
-                    if i == level.displayattr[0]-1:
-                        break
-                    pos += level.colwidths[attrname] + 1
-                level.moveto(pos, level.cury)
-
-        def cmd_nextattr(self):
-            level = self.levels[-1]
-            if level.displayattr[0] is None or level.displayattr[0] == len(level.displayattrs)-1:
-                self.beep()
-            else:
-                self.report("nextattr")
-                pos = 0
-                for (i, attrname) in enumerate(level.displayattrs):
-                    if i == level.displayattr[0]+1:
-                        break
-                    pos += level.colwidths[attrname] + 1
-                level.moveto(pos, level.cury)
-
-        def cmd_pick(self):
-            level = self.levels[-1]
-            self.returnvalue = level.items[level.cury].item
-            return True
-
-        def cmd_pickattr(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            attr = _getattr(level.items[level.cury].item, attrname)
-            if attr is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-            else:
-                self.returnvalue = attr
-                return True
-
-        def cmd_pickallattrs(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            result = []
-            for cache in level.items:
-                attr = _getattr(cache.item, attrname)
-                if attr is not _default:
-                    result.append(attr)
-            self.returnvalue = result
-            return True
-
-        def cmd_pickmarked(self):
-            level = self.levels[-1]
-            self.returnvalue = [cache.item for cache in level.items if cache.marked]
-            return True
-
-        def cmd_pickmarkedattr(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            result = []
-            for cache in level.items:
-                if cache.marked:
-                    attr = _getattr(cache.item, attrname)
-                    if attr is not _default:
-                        result.append(attr)
-            self.returnvalue = result
-            return True
-
-        def cmd_markrange(self):
-            level = self.levels[-1]
-            self.report("markrange")
-            start = None
-            if level.items:
-                for i in xrange(level.cury, -1, -1):
-                    if level.items[i].marked:
-                        start = i
-                        break
-            if start is None:
-                self.report(CommandError("no mark before cursor"))
-                curses.beep()
-            else:
-                for i in xrange(start, level.cury+1):
-                    cache = level.items[i]
-                    if not cache.marked:
-                        cache.marked = True
-                        level.marked += 1
-
-        def cmd_enterdefault(self):
-            level = self.levels[-1]
-            try:
-                item = level.items[level.cury].item
-            except IndexError:
-                self.report(CommandError("No object"))
-                curses.beep()
-            else:
-                self.report("entering object (default mode)...")
-                self.enter(item, "default")
-
-        def cmd_leave(self):
-            self.report("leave")
-            if len(self.levels) > 1:
-                self._calcheaderlines(len(self.levels)-1)
-                self.levels.pop(-1)
-            else:
-                self.report(CommandError("This is the last level"))
-                curses.beep()
-
-        def cmd_enter(self):
-            level = self.levels[-1]
-            try:
-                item = level.items[level.cury].item
-            except IndexError:
-                self.report(CommandError("No object"))
-                curses.beep()
-            else:
-                self.report("entering object...")
-                self.enter(item, None)
-
-        def cmd_enterattr(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            try:
-                item = level.items[level.cury].item
-            except IndexError:
-                self.report(CommandError("No object"))
-                curses.beep()
-            else:
-                attr = _getattr(item, attrname)
-                if attr is _default:
-                    self.report(AttributeError(_attrname(attrname)))
-                else:
-                    self.report("entering object attribute %s..." % _attrname(attrname))
-                    self.enter(attr, None)
-
-        def cmd_detail(self):
-            level = self.levels[-1]
-            try:
-                item = level.items[level.cury].item
-            except IndexError:
-                self.report(CommandError("No object"))
-                curses.beep()
-            else:
-                self.report("entering detail view for object...")
-                self.enter(item, "detail")
-
-        def cmd_detailattr(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            try:
-                item = level.items[level.cury].item
-            except IndexError:
-                self.report(CommandError("No object"))
-                curses.beep()
-            else:
-                attr = _getattr(item, attrname)
-                if attr is _default:
-                    self.report(AttributeError(_attrname(attrname)))
-                else:
-                    self.report("entering detail view for attribute...")
-                    self.enter(attr, "detail")
-
-        def cmd_tooglemark(self):
-            level = self.levels[-1]
-            self.report("toggle mark")
-            try:
-                item = level.items[level.cury]
-            except IndexError: # no items?
-                pass
-            else:
-                if item.marked:
-                    item.marked = False
-                    level.marked -= 1
-                else:
-                    item.marked = True
-                    level.marked += 1
-
-        def cmd_sortattrasc(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            self.report("sort by %s (ascending)" % _attrname(attrname))
-            def key(item):
-                try:
-                    return _getattr(item, attrname, None)
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception:
-                    return None
-            level.sort(key)
-
-        def cmd_sortattrdesc(self):
-            level = self.levels[-1]
-            attrname = level.displayattr[1]
-            if attrname is _default:
-                curses.beep()
-                self.report(AttributeError(_attrname(attrname)))
-                return
-            self.report("sort by %s (descending)" % _attrname(attrname))
-            def key(item):
-                try:
-                    return _getattr(item, attrname, None)
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception:
-                    return None
-            level.sort(key, reverse=True)
-
-        def cmd_goto(self):
-            self.startkeyboardinput("goto")
-
-        def exe_goto(self):
-            level = self.levels[-1]
-            if self.keyboardinput:
-                level.moveto(level.curx, int(self.keyboardinput))
-
-        def cmd_find(self):
-            self.startkeyboardinput("find")
-
-        def exe_find(self):
-            level = self.levels[-1]
-            if self.keyboardinput:
-                while True:
-                    cury = level.cury
-                    level.moveto(level.curx, cury+1)
-                    if cury == level.cury:
-                        curses.beep()
-                        break
-                    item = level.items[level.cury].item
-                    try:
-                        if eval(self.keyboardinput, globals(), _AttrNamespace(item)):
-                            break
-                    except (KeyboardInterrupt, SystemExit):
-                        raise
-                    except Exception, exc:
-                        self.report(exc)
-                        curses.beep()
-                        break # break on error
-
-        def cmd_findbackwards(self):
-            self.startkeyboardinput("findbackwards")
-
-        def exe_findbackwards(self):
-            level = self.levels[-1]
-            if self.keyboardinput:
-                while level.cury:
-                    level.moveto(level.curx, level.cury-1)
-                    item = level.items[level.cury].item
-                    try:
-                        if eval(self.keyboardinput, globals(), _AttrNamespace(item)):
-                            break
-                    except (KeyboardInterrupt, SystemExit):
-                        raise
-                    except Exception, exc:
-                        self.report(exc)
-                        curses.beep()
-                        break # break on error
-                else:
-                    curses.beep()
-
-        def cmd_help(self):
-            """
-            The help command
-            """
-            for level in self.levels:
-                if isinstance(level.input, _BrowserHelp):
-                    curses.beep()
-                    self.report(CommandError("help already active"))
-                    return
-
-            self.enter(_BrowserHelp(self), "default")
-
-        def _dodisplay(self, scr):
-            """
-            This method is the workhorse of the browser. It handles screen
-            drawing and the keyboard.
-            """
-            self.scr = scr
-            curses.halfdelay(1)
-            footery = 2
-
-            keys = []
-            for (key, cmd) in self.keymap.iteritems():
-                if cmd == "quit":
-                    keys.append("%s=%s" % (self.keylabel(key), cmd))
-            for (key, cmd) in self.keymap.iteritems():
-                if cmd == "help":
-                    keys.append("%s=%s" % (self.keylabel(key), cmd))
-            helpmsg = " | %s" % " ".join(keys)
-
-            scr.clear()
-            msg = "Fetching first batch of objects..."
-            (self.scrsizey, self.scrsizex) = scr.getmaxyx()
-            scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
-            scr.refresh()
-
-            lastc = -1
-
-            self.levels = []
-            # enter the first level
-            self.enter(self.input, xiter(self.input, "default"), *self.attrs)
-
-            self._calcheaderlines(None)
-
-            while True:
-                level = self.levels[-1]
-                (self.scrsizey, self.scrsizex) = scr.getmaxyx()
-                level.mainsizey = self.scrsizey-1-self._headerlines-footery
-
-                # Paint object header
-                for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
-                    lv = self.levels[i]
-                    posx = 0
-                    posy = i-self._firstheaderline
-                    endx = self.scrsizex
-                    if i: # not the first level
-                        msg = " (%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
-                        if not self.levels[i-1].exhausted:
-                            msg += "+"
-                        msg += ") "
-                        endx -= len(msg)+1
-                    posx += self.addstr(posy, posx, 0, endx, " ibrowse #%d: " % i, self.style_objheadertext)
-                    for (style, text) in lv.header:
-                        posx += self.addstr(posy, posx, 0, endx, text, self.style_objheaderobject)
-                        if posx >= endx:
-                            break
-                    if i:
-                        posx += self.addstr(posy, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
-                    posx += self.addchr(posy, posx, 0, self.scrsizex, " ", self.scrsizex-posx, self.style_objheadernumber)
-
-                if not level.items:
-                    self.addchr(self._headerlines, 0, 0, self.scrsizex, " ", self.scrsizex, self.style_colheader)
-                    self.addstr(self._headerlines+1, 0, 0, self.scrsizex, " <empty>", style_error)
-                    scr.clrtobot()
-                else:
-                    # Paint column headers
-                    scr.move(self._headerlines, 0)
-                    scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
-                    scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
-                    begx = level.numbersizex+3
-                    posx = begx-level.datastartx
-                    for attrname in level.displayattrs:
-                        strattrname = _attrname(attrname)
-                        cwidth = level.colwidths[attrname]
-                        header = strattrname.ljust(cwidth)
-                        if attrname == level.displayattr[1]:
-                            style = self.style_colheaderhere
-                        else:
-                            style = self.style_colheader
-                        posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, header, style)
-                        posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, self.headersepchar, self.style_colheadersep)
-                        if posx >= self.scrsizex:
-                            break
-                    else:
-                        scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_colheader))
-
-                    # Paint rows
-                    posy = self._headerlines+1+level.datastarty
-                    for i in xrange(level.datastarty, min(level.datastarty+level.mainsizey, len(level.items))):
-                        cache = level.items[i]
-                        if i == level.cury:
-                            style = self.style_numberhere
-                        else:
-                            style = self.style_number
-
-                        posy = self._headerlines+1+i-level.datastarty
-                        posx = begx-level.datastartx
-
-                        scr.move(posy, 0)
-                        scr.addstr(" %*d%s" % (level.numbersizex, i, " !"[cache.marked]), self.getstyle(style))
-                        scr.addstr(self.headersepchar, self.getstyle(self.style_sep))
-
-                        for attrname in level.displayattrs:
-                            cwidth = level.colwidths[attrname]
-                            try:
-                                (align, length, parts) = level.displayrows[i-level.datastarty][attrname]
-                            except KeyError:
-                                align = 2
-                                style = style_nodata
-                            padstyle = self.style_datapad
-                            sepstyle = self.style_sep
-                            if i == level.cury:
-                                padstyle = self.getstylehere(padstyle)
-                                sepstyle = self.getstylehere(sepstyle)
-                            if align == 2:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.nodatachar, cwidth, style)
-                            else:
-                                if align == 1:
-                                    posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
-                                elif align == 0:
-                                    pad1 = (cwidth-length)//2
-                                    pad2 = cwidth-length-len(pad1)
-                                    posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad1, padstyle)
-                                for (style, text) in parts:
-                                    if i == level.cury:
-                                        style = self.getstylehere(style)
-                                    posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
-                                    if posx >= self.scrsizex:
-                                        break
-                                if align == -1:
-                                    posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
-                                elif align == 0:
-                                    posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad2, padstyle)
-                            posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
-                        else:
-                            scr.clrtoeol()
-
-                    # Add blank row headers for the rest of the screen
-                    for posy in xrange(posy+1, self.scrsizey-2):
-                        scr.addstr(posy, 0, " " * (level.numbersizex+2), self.getstyle(self.style_colheader))
-                        scr.clrtoeol()
-
-                posy = self.scrsizey-footery
-                # Display footer
-                scr.addstr(posy, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
-
-                if level.exhausted:
-                    flag = ""
-                else:
-                    flag = "+"
-
-                endx = self.scrsizex-len(helpmsg)-1
-                scr.addstr(posy, endx, helpmsg, self.getstyle(self.style_footer))
-
-                posx = 0
-                msg = " %d%s objects (%d marked): " % (len(level.items), flag, level.marked)
-                posx += self.addstr(posy, posx, 0, endx, msg, self.style_footer)
-                try:
-                    item = level.items[level.cury].item
-                except IndexError: # empty
-                    pass
-                else:
-                    for (nostyle, text) in xrepr(item, "footer"):
-                        if not isinstance(nostyle, int):
-                            posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
-                            if posx >= endx:
-                                break
-
-                    attrstyle = [(astyle.style_default, "no attribute")]
-                    attrname = level.displayattr[1]
-                    if attrname is not _default and attrname is not None:
-                        posx += self.addstr(posy, posx, 0, endx, " | ", self.style_footer)
-                        posx += self.addstr(posy, posx, 0, endx, _attrname(attrname), self.style_footer)
-                        posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
-                        try:
-                            attr = _getattr(item, attrname)
-                        except (SystemExit, KeyboardInterrupt):
-                            raise
-                        except Exception, exc:
-                            attr = exc
-                        if attr is not _default:
-                            attrstyle = xrepr(attr, "footer")
-                        for (nostyle, text) in attrstyle:
-                            if not isinstance(nostyle, int):
-                                posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
-                                if posx >= endx:
-                                    break
-
-                try:
-                    # Display input prompt
-                    if self.mode in self.prompts:
-                        scr.addstr(self.scrsizey-1, 0,
-                                   self.prompts[self.mode] + self.keyboardinput,
-                                   self.getstyle(style_default))
-                    # Display report
-                    else:
-                        if self._report is not None:
-                            if isinstance(self._report, Exception):
-                                style = self.getstyle(style_error)
-                                if self._report.__class__.__module__ == "exceptions":
-                                    msg = "%s: %s" % \
-                                          (self._report.__class__.__name__, self._report)
-                                else:
-                                    msg = "%s.%s: %s" % \
-                                          (self._report.__class__.__module__,
-                                           self._report.__class__.__name__, self._report)
-                            else:
-                                style = self.getstyle(self.style_report)
-                                msg = self._report
-                            scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
-                            self._report = None
-                        else:
-                            scr.move(self.scrsizey-1, 0)
-                except curses.error:
-                    # Protect against error from writing to the last line
-                    pass
-                scr.clrtoeol()
-
-                # Position cursor
-                if self.mode in self.prompts:
-                    scr.move(self.scrsizey-1, len(self.prompts[self.mode])+self.cursorpos)
-                else:
-                    scr.move(
-                        1+self._headerlines+level.cury-level.datastarty,
-                        level.numbersizex+3+level.curx-level.datastartx
-                    )
-                scr.refresh()
-
-                # Check keyboard
-                while True:
-                    c = scr.getch()
-                    if self.mode in self.prompts:
-                        if c in (8, 127, curses.KEY_BACKSPACE):
-                            if self.cursorpos:
-                                self.keyboardinput = self.keyboardinput[:self.cursorpos-1] + self.keyboardinput[self.cursorpos:]
-                                self.cursorpos -= 1
-                                break
-                            else:
-                                curses.beep()
-                        elif c == curses.KEY_LEFT:
-                            if self.cursorpos:
-                                self.cursorpos -= 1
-                                break
-                            else:
-                                curses.beep()
-                        elif c == curses.KEY_RIGHT:
-                            if self.cursorpos < len(self.keyboardinput):
-                                self.cursorpos += 1
-                                break
+    from ibrowse import ibrowse
+except ImportError:
+    # No curses (probably Windows) => use ``idump`` as the default display.
+    defaultdisplay = idump
                             else:
-                                curses.beep()
-                        elif c in (curses.KEY_UP, curses.KEY_DOWN): # cancel
-                            self.mode = "default"
-                            break
-                        elif c == ord("\n"):
-                            self.executekeyboardinput(self.mode)
-                            break
-                        elif c != -1:
-                           try:
-                               c = chr(c)
-                           except ValueError:
-                               curses.beep()
-                           else:
-                               if (self.mode == "goto" and not "0" <= c <= "9"):
-                                   curses.beep()
-                               else:
-                                   self.keyboardinput = self.keyboardinput[:self.cursorpos] + c + self.keyboardinput[self.cursorpos:]
-                                   self.cursorpos += 1
-                                   break # Redisplay
-                    else:
-                        # if no key is pressed slow down and beep again
-                        if c == -1:
-                            self.stepx = 1.
-                            self.stepy = 1.
-                            self._dobeep = True
-                        else:
-                            # if a different key was pressed slow down and beep too
-                            if c != lastc:
-                                lastc = c
-                                self.stepx = 1.
-                                self.stepy = 1.
-                                self._dobeep = True
-                            cmdname = self.keymap.get(c, None)
-                            if cmdname is None:
-                                self.report(
-                                    UnassignedKeyError("Unassigned key %s" %
-                                                       self.keylabel(c)))
-                            else:
-                                cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
-                                if cmdfunc is None:
-                                    self.report(
-                                        UnknownCommandError("Unknown command %r" %
-                                                            (cmdname,)))
-                                elif cmdfunc():
-                                    returnvalue = self.returnvalue
-                                    self.returnvalue = None
-                                    return returnvalue
-                            self.stepx = self.nextstepx(self.stepx)
-                            self.stepy = self.nextstepy(self.stepy)
-                            curses.flushinp() # get rid of type ahead
-                            break # Redisplay
-            self.scr = None
-
-        def display(self):
-            return curses.wrapper(self._dodisplay)
-
     defaultdisplay = ibrowse
     __all__.append("ibrowse")
-else:
-    # No curses (probably Windows) => use ``idump`` as the default display.
-    defaultdisplay = idump
 
 
 # If we're running under IPython, install an IPython displayhook that
 # returns the object from Display.display(), else install a displayhook
 # directly as sys.displayhook
 try:
     from IPython import ipapi
     api = ipapi.get()
 except (ImportError, AttributeError):
     api = None
 
 if api is not None:
     def displayhook(self, obj):
         if isinstance(obj, type) and issubclass(obj, Table):
             obj = obj()
         if isinstance(obj, Table):
             obj = obj | defaultdisplay
         if isinstance(obj, Display):
             return obj.display()
         else:
             raise ipapi.TryNext
     api.set_hook("result_display", displayhook)
 else:
     def installdisplayhook():
         _originalhook = sys.displayhook
         def displayhook(obj):
             if isinstance(obj, type) and issubclass(obj, Table):
                 obj = obj()
             if isinstance(obj, Table):
                 obj = obj | defaultdisplay
             if isinstance(obj, Display):
                 return obj.display()
             else:
                 _originalhook(obj)
         sys.displayhook = displayhook
     installdisplayhook()