* IPython/Extensions/ipipe.py: Rename XAttr to AttributeDetail

and make it iterable (iterating over the attribute itself). Add two new
magic strings for __xattrs__(): If the string starts with "-", the attribute
will not be displayed in ibrowse's detail view (but it can still be
iterated over). This makes it possible to add attributes that are large
lists or generator methods to the detail view. Replace magic attribute names
and _attrname() and _getattr() with "descriptors": For each type of magic
attribute name there's a subclass of Descriptor: None -> SelfDescriptor();
"foo" -> AttributeDescriptor("foo"); "foo()" -> MethodDescriptor("foo");
"-foo" -> IterAttributeDescriptor("foo"); "-foo()" -> IterMethodDescriptor("foo");
foo() -> FunctionDescriptor(foo). Magic strings returned from __xattrs__()
are still supported.

* IPython/Extensions/ibrowse.py: If fetching the next row from the input
fails in ibrowse.fetch(), the exception object is added as the last item
and item fetching is canceled. This prevents ibrowse from aborting if e.g.
a generator throws an exception midway through execution.

* IPython/Extensions/ipipe.py: Turn ifile's properties mimetype and
encoding into methods.

IPython/Extensions/astyle.py

@@ -1,390 +1,391 b''
 """
 ``astyle`` provides classes for adding style (foreground and background color;
 bold; blink; etc.) to terminal and curses output.
 """
 
 
 import sys, os
 
 try:
     import curses
 except ImportError:
     curses = None
 
 
 COLOR_BLACK   = 0
 COLOR_RED     = 1
 COLOR_GREEN   = 2
 COLOR_YELLOW  = 3
 COLOR_BLUE    = 4
 COLOR_MAGENTA = 5
 COLOR_CYAN    = 6
 COLOR_WHITE   = 7
 
 A_BLINK     = 1<<0 # Blinking text
 A_BOLD      = 1<<1 # Extra bright or bold text
 A_DIM       = 1<<2 # Half bright text
 A_REVERSE   = 1<<3 # Reverse-video text
 A_STANDOUT  = 1<<4 # The best highlighting mode available
 A_UNDERLINE = 1<<5 # Underlined text
 
 
 class Style(object):
     """
     Store foreground color, background color and attribute (bold, underlined
     etc.).
     """
     __slots__ = ("fg", "bg", "attrs")
 
     COLORNAMES = {
         "black": COLOR_BLACK,
         "red": COLOR_RED,
         "green": COLOR_GREEN,
         "yellow": COLOR_YELLOW,
         "blue": COLOR_BLUE,
         "magenta": COLOR_MAGENTA,
         "cyan": COLOR_CYAN,
         "white": COLOR_WHITE,
     }
     ATTRNAMES = {
         "blink": A_BLINK,
         "bold": A_BOLD,
         "dim": A_DIM,
         "reverse": A_REVERSE,
         "standout": A_STANDOUT,
         "underline": A_UNDERLINE,
     }
 
     def __init__(self, fg, bg, attrs=0):
         """
         Create a ``Style`` object with ``fg`` as the foreground color,
         ``bg`` as the background color and ``attrs`` as the attributes.
 
         Examples:
 
             >>> Style(COLOR_RED, COLOR_BLACK)
             >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE)
         """
         self.fg = fg
         self.bg = bg
         self.attrs = attrs
 
     def __call__(self, *args):
         text = Text()
         for arg in args:
             if isinstance(arg, Text):
                 text.extend(arg)
             else:
                 text.append((self, arg))
         return text
 
     def __eq__(self, other):
         return self.fg == other.fg and self.bg == other.bg and self.attrs == other.attrs
 
     def __neq__(self, other):
         return self.fg != other.fg or self.bg != other.bg or self.attrs != other.attrs
 
     def __repr__(self):
         color2name = ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white")
         attrs2name = ("blink", "bold", "dim", "reverse", "standout", "underline")
 
         return "<%s fg=%s bg=%s attrs=%s>" % (
             self.__class__.__name__, color2name[self.fg], color2name[self.bg],
             "|".join([attrs2name[b] for b in xrange(6) if self.attrs&(1<<b)]) or 0)
 
     def fromstr(cls, value):
         """
         Create a ``Style`` object from a string. The format looks like this:
         ``"red:black:bold|blink"``.
         """
         # defaults
         fg = COLOR_WHITE
         bg = COLOR_BLACK
         attrs = 0
 
         parts = value.split(":")
         if len(parts) > 0:
             fg = cls.COLORNAMES[parts[0].lower()]
             if len(parts) > 1:
                 bg = cls.COLORNAMES[parts[1].lower()]
                 if len(parts) > 2:
                     for strattr in parts[2].split("|"):
                         attrs |= cls.ATTRNAMES[strattr.lower()]
         return cls(fg, bg, attrs)
     fromstr = classmethod(fromstr)
 
     def fromenv(cls, name, default):
         """
         Create a ``Style`` from an environment variable named ``name``
         (using ``default`` if the environment variable doesn't exist).
         """
         return cls.fromstr(os.environ.get(name, default))
     fromenv = classmethod(fromenv)
 
 
 def switchstyle(s1, s2):
     """
     Return the ANSI escape sequence needed to switch from style ``s1`` to
     style ``s2``.
     """
     attrmask = (A_BLINK|A_BOLD|A_UNDERLINE|A_REVERSE)
     a1 = s1.attrs & attrmask
     a2 = s2.attrs & attrmask
 
     args = []
     if s1 != s2:
         # do we have to get rid of the bold/underline/blink bit?
         # (can only be done by a reset)
         # use reset when our target color is the default color
         # (this is shorter than 37;40)
         if (a1 & ~a2 or s2==style_default):
             args.append("0")
             s1 = style_default
             a1 = 0
 
         # now we know that old and new color have the same boldness,
         # or the new color is bold and the old isn't,
         # i.e. we only might have to switch bold on, not off
         if not (a1 & A_BOLD) and (a2 & A_BOLD):
             args.append("1")
 
         # Fix underline
         if not (a1 & A_UNDERLINE) and (a2 & A_UNDERLINE):
             args.append("4")
 
         # Fix blink
         if not (a1 & A_BLINK) and (a2 & A_BLINK):
             args.append("5")
 
         # Fix reverse
         if not (a1 & A_REVERSE) and (a2 & A_REVERSE):
             args.append("7")
 
         # Fix foreground color
         if s1.fg != s2.fg:
             args.append("3%d" % s2.fg)
 
         # Finally fix the background color
         if s1.bg != s2.bg:
             args.append("4%d" % s2.bg)
 
         if args:
             return "\033[%sm" % ";".join(args)
     return ""
 
 
 class Text(list):
     """
     A colored string. A ``Text`` object is a sequence, the sequence
     items will be ``(style, string)`` tuples.
     """
 
     def __init__(self, *args):
         list.__init__(self)
         self.append(*args)
 
     def __repr__(self):
         return "%s.%s(%s)" % (
             self.__class__.__module__, self.__class__.__name__,
             list.__repr__(self)[1:-1])
 
     def append(self, *args):
         for arg in args:
             if isinstance(arg, Text):
                 self.extend(arg)
             elif isinstance(arg, tuple): # must be (style, string)
                 list.append(self, arg)
             elif isinstance(arg, unicode):
                 list.append(self, (style_default, arg))
             else:
                 list.append(self, (style_default, str(arg)))
 
     def insert(self, index, *args):
         self[index:index] = Text(*args)
 
     def __add__(self, other):
         new = Text()
         new.append(self)
         new.append(other)
         return new
 
     def __iadd__(self, other):
         self.append(other)
         return self
 
     def format(self, styled=True):
         """
         This generator yields the strings that will make up the final
         colorized string.
         """
         if styled:
             oldstyle = style_default
             for (style, string) in self:
                 if not isinstance(style, (int, long)):
                     switch = switchstyle(oldstyle, style)
                     if switch:
                         yield switch
                     if string:
                         yield string
                     oldstyle = style
             switch = switchstyle(oldstyle, style_default)
             if switch:
                 yield switch
         else:
             for (style, string) in self:
                 if not isinstance(style, (int, long)):
                     yield string
 
     def string(self, styled=True):
         """
         Return the resulting string (with escape sequences, if ``styled``
         is true).
         """
         return "".join(self.format(styled))
 
     def __str__(self):
         """
         Return ``self`` as a string (without ANSI escape sequences).
         """
         return self.string(False)
 
     def write(self, stream, styled=True):
         """
         Write ``self`` to the output stream ``stream`` (with escape sequences,
         if ``styled`` is true).
         """
         for part in self.format(styled):
             stream.write(part)
 
     def __xrepr__(self, mode="default"):
         yield (-1, True)
         for info in self:
             yield info
 
 
 def streamstyle(stream, styled=None):
     """
     If ``styled`` is ``None``, return whether ``stream`` refers to a terminal.
     If this can't be determined (either because ``stream`` doesn't refer to a
     real OS file, or because you're on Windows) return ``False``. If ``styled``
     is not ``None`` ``styled`` will be returned unchanged.
     """
     if styled is None:
         try:
             styled = os.isatty(stream.fileno())
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception:
             styled = False
     return styled
 
 
 def write(stream, styled, *texts):
     """
     Write ``texts`` to ``stream``.
     """
     text = Text(*texts)
     text.write(stream, streamstyle(stream, styled))
 
 
 def writeln(stream, styled, *texts):
     """
     Write ``texts`` to ``stream`` and finish with a line feed.
     """
     write(stream, styled, *texts)
     stream.write("\n")
 
 
 class Stream(object):
     """
     Stream wrapper that adds color output.
     """
     def __init__(self, stream, styled=None):
         self.stream = stream
         self.styled = streamstyle(stream, styled)
 
     def write(self, *texts):
         write(self.stream, self.styled, *texts)
 
     def writeln(self, *texts):
         writeln(self.stream, self.styled, *texts)
 
     def __getattr__(self, name):
         return getattr(self.stream, name)
 
 
 class stdout(object):
     """
     Stream wrapper for ``sys.stdout`` that adds color output.
     """
     def write(self, *texts):
         write(sys.stdout, None, *texts)
 
     def writeln(self, *texts):
         writeln(sys.stdout, None, *texts)
 
     def __getattr__(self, name):
         return getattr(sys.stdout, name)
 stdout = stdout()
 
 
 class stderr(object):
     """
     Stream wrapper for ``sys.stderr`` that adds color output.
     """
     def write(self, *texts):
         write(sys.stderr, None, *texts)
 
     def writeln(self, *texts):
         writeln(sys.stderr, None, *texts)
 
     def __getattr__(self, name):
         return getattr(sys.stdout, name)
 stderr = stderr()
 
 
 if curses is not None:
     # This is probably just range(8)
     COLOR2CURSES = [
         COLOR_BLACK,
         COLOR_RED,
         COLOR_GREEN,
         COLOR_YELLOW,
         COLOR_BLUE,
         COLOR_MAGENTA,
         COLOR_CYAN,
         COLOR_WHITE,
     ]
 
     A2CURSES = {
         A_BLINK: curses.A_BLINK,
         A_BOLD: curses.A_BOLD,
         A_DIM: curses.A_DIM,
         A_REVERSE: curses.A_REVERSE,
         A_STANDOUT: curses.A_STANDOUT,
         A_UNDERLINE: curses.A_UNDERLINE,
     }
 
 
 # default style
 style_default = Style.fromstr("white:black")
 
 # Styles for datatypes
 style_type_none = Style.fromstr("magenta:black")
 style_type_bool = Style.fromstr("magenta:black")
 style_type_number = Style.fromstr("yellow:black")
 style_type_datetime = Style.fromstr("magenta:black")
+style_type_type = Style.fromstr("cyan:black")
 
 # Style for URLs and file/directory names
 style_url = Style.fromstr("green:black")
 style_dir = Style.fromstr("cyan:black")
 style_file = Style.fromstr("green:black")
 
 # Style for ellipsis (when an output has been shortened
 style_ellisis = Style.fromstr("red:black")
 
 # Style for displaying exceptions
 style_error = Style.fromstr("red:black")
 
 # Style for displaying non-existing attributes
 style_nodata = Style.fromstr("red:black")

IPython/Extensions/ibrowse.py

@@ -1,1665 +1,1679 b''
 # -*- coding: iso-8859-1 -*-
 
 import curses, fcntl, signal, struct, tty, textwrap, inspect
 
 import astyle, ipipe
 
 
 # Python 2.3 compatibility
 try:
     set
 except NameError:
     import sets
     set = sets.Set
 
 
 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 Keymap(dict):
     """
     Stores mapping of keys to commands.
     """
     def __init__(self):
         self._keymap = {}
 
     def __setitem__(self, key, command):
         if isinstance(key, str):
             for c in key:
                 dict.__setitem__(self, ord(c), command)
         else:
             dict.__setitem__(self, key, command)
 
     def __getitem__(self, key):
         if isinstance(key, str):
             key = ord(key)
         return dict.__getitem__(self, key)
 
     def __detitem__(self, key):
         if isinstance(key, str):
             key = ord(key)
         dict.__detitem__(self, key)
 
     def register(self, command, *keys):
         for key in keys:
             self[key] = command
 
     def get(self, key, default=None):
         if isinstance(key, str):
             key = ord(key)
         return dict.get(self, key, default)
 
     def findkey(self, command, default=ipipe.noitem):
         for (key, commandcandidate) in self.iteritems():
             if commandcandidate == command:
                 return key
         if default is ipipe.noitem:
             raise KeyError(command)
         return default
 
 
 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("yellow:black:bold")
     # 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):
+    def __iter__(self):
         # Get reverse key mapping
         allkeys = {}
         for (key, cmd) in self.browser.keymap.iteritems():
             allkeys.setdefault(cmd, []).append(key)
 
         fields = ("key", "description")
 
         commands = []
         for name in dir(self.browser):
             if name.startswith("cmd_"):
                 command = getattr(self.browser, name)
                 commands.append((inspect.getsourcelines(command)[-1], name[4:], command))
         commands.sort()
         commands = [(c[1], c[2]) for c in commands]
         for (i, (name, command)) in enumerate(commands):
             if i:
                 yield ipipe.Fields(fields, key="", description="")
 
             description = command.__doc__
             if description is None:
                 lines = []
             else:
                 lines = [l.strip() for l in description.splitlines() if l.strip()]
                 description = "\n".join(lines)
                 lines = textwrap.wrap(description, 60)
             keys = allkeys.get(name, [])
 
-            yield ipipe.Fields(fields, description=astyle.Text((self.style_header, name)))
+            yield ipipe.Fields(fields, key="", 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 ipipe.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)
+        # Attributes to display (in this order)
         self.displayattrs = []
 
-        # index and name of attribute under the cursor
+        # index and attribute under the cursor
         self.displayattr = (None, ipipe.noitem)
 
-        # Maps attribute names to column widths
+        # Maps attributes to column widths
         self.colwidths = {}
 
         # Set of hidden attributes
         self.hiddenattrs = set()
 
         # This takes care of all the caches etc.
         self.moveto(0, 0, refresh=True)
 
     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
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                have += 1
+                self.items.append(_BrowserCachedItem(exc))
+                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()
+        attrs = set()
         self.displayattrs = []
         if self.attrs:
             # If the browser object specifies a fixed list of attributes,
             # simply use it (removing hidden attributes).
-            for attrname in self.attrs:
-                if attrname not in attrnames and attrname not in self.hiddenattrs:
-                    self.displayattrs.append(attrname)
-                    attrnames.add(attrname)
+            for attr in self.attrs:
+                attr = ipipe.upgradexattr(attr)
+                if attr not in attrs and attr not in self.hiddenattrs:
+                    self.displayattrs.append(attr)
+                    attrs.add(attr)
         else:
             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 and attrname not in self.hiddenattrs:
-                        self.displayattrs.append(attrname)
-                        attrnames.add(attrname)
+                for attr in ipipe.xattrs(self.items[i].item, "default"):
+                    if attr not in attrs and attr not in self.hiddenattrs:
+                        self.displayattrs.append(attr)
+                        attrs.add(attr)
 
     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:
+        for attr in self.displayattrs:
             try:
-                value = ipipe._getattr(item, attrname, ipipe.noitem)
+                value = attr.value(item)
             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.noitem:
                 # remember alignment, length and colored text
-                row[attrname] = ipipe.xformat(value, "cell", self.browser.maxattrlength)
+                row[attr] = ipipe.xformat(value, "cell", self.browser.maxattrlength)
         return row
 
     def calcwidths(self):
         # Recalculate the displayed fields and their widths.
         # ``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
         # column names to widths.
         self.colwidths = {}
         for row in self.displayrows:
-            for attrname in self.displayattrs:
+            for attr in self.displayattrs:
                 try:
-                    length = row[attrname][1]
+                    length = row[attr][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
+                if attr not in self.colwidths:
+                    self.colwidths[attr] = len(attr.name())
+                newwidth = max(self.colwidths[attr], length)
+                self.colwidths[attr] = newwidth
 
         # How many characters do we need to paint the largest 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 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)
+        for (i, attr) in enumerate(self.displayattrs):
+            if pos+self.colwidths[attr] >= self.curx:
+                self.displayattr = (i, attr)
                 break
-            pos += self.colwidths[attrname]+1
+            pos += self.colwidths[attr]+1
         else:
             self.displayattr = (None, ipipe.noitem)
 
     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
         # try to get enough items to fill the screen
         self.fetch(max(y+scrollbordery+1, self.mainsizey))
         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(min(olddatastarty, self.datastarty+self.mainsizey)-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(max(olddatastarty+self.mainsizey, self.datastarty),
                                 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 _CommandInput(object):
     keymap = Keymap()
     keymap.register("left", curses.KEY_LEFT)
     keymap.register("right", curses.KEY_RIGHT)
     keymap.register("home", curses.KEY_HOME, "\x01") # Ctrl-A
     keymap.register("end", curses.KEY_END, "\x05") # Ctrl-E
     # FIXME: What's happening here?
     keymap.register("backspace", curses.KEY_BACKSPACE, "\x08\x7f")
     keymap.register("delete", curses.KEY_DC)
     keymap.register("delend", 0x0b) # Ctrl-K
     keymap.register("execute", "\r\n")
     keymap.register("up", curses.KEY_UP)
     keymap.register("down", curses.KEY_DOWN)
     keymap.register("incsearchup", curses.KEY_PPAGE)
     keymap.register("incsearchdown", curses.KEY_NPAGE)
     keymap.register("exit", "\x18"), # Ctrl-X
 
     def __init__(self, prompt):
         self.prompt = prompt
         self.history = []
         self.maxhistory = 100
         self.input = ""
         self.curx = 0
         self.cury = -1 # blank line
 
     def start(self):
         self.input = ""
         self.curx = 0
         self.cury = -1 # blank line
 
     def handlekey(self, browser, key):
         cmdname = self.keymap.get(key, None)
         if cmdname is not None:
             cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
             if cmdfunc is not None:
                 return cmdfunc(browser)
             curses.beep()
         elif key != -1:
             try:
                 char = chr(key)
             except ValueError:
                 curses.beep()
             else:
                 return self.handlechar(browser, char)
 
     def handlechar(self, browser, char):
         self.input = self.input[:self.curx] + char + self.input[self.curx:]
         self.curx += 1
         return True
 
     def dohistory(self):
         self.history.insert(0, self.input)
         del self.history[:-self.maxhistory]
 
     def cmd_backspace(self, browser):
         if self.curx:
             self.input = self.input[:self.curx-1] + self.input[self.curx:]
             self.curx -= 1
             return True
         else:
             curses.beep()
 
     def cmd_delete(self, browser):
         if self.curx<len(self.input):
             self.input = self.input[:self.curx] + self.input[self.curx+1:]
             return True
         else:
             curses.beep()
 
     def cmd_delend(self, browser):
         if self.curx<len(self.input):
             self.input = self.input[:self.curx]
             return True
 
     def cmd_left(self, browser):
         if self.curx:
             self.curx -= 1
             return True
         else:
             curses.beep()
 
     def cmd_right(self, browser):
         if self.curx < len(self.input):
             self.curx += 1
             return True
         else:
             curses.beep()
 
     def cmd_home(self, browser):
         if self.curx:
             self.curx = 0
             return True
         else:
             curses.beep()
 
     def cmd_end(self, browser):
         if self.curx < len(self.input):
             self.curx = len(self.input)
             return True
         else:
             curses.beep()
 
     def cmd_up(self, browser):
         if self.cury < len(self.history)-1:
             self.cury += 1
             self.input = self.history[self.cury]
             self.curx = len(self.input)
             return True
         else:
             curses.beep()
 
     def cmd_down(self, browser):
         if self.cury >= 0:
             self.cury -= 1
             if self.cury>=0:
                 self.input = self.history[self.cury]
             else:
                 self.input = ""
             self.curx = len(self.input)
             return True
         else:
             curses.beep()
 
     def cmd_incsearchup(self, browser):
         prefix = self.input[:self.curx]
         cury = self.cury
         while True:
             cury += 1
             if cury >= len(self.history):
                 break
             if self.history[cury].startswith(prefix):
                 self.input = self.history[cury]
                 self.cury = cury
                 return True
         curses.beep()
 
     def cmd_incsearchdown(self, browser):
         prefix = self.input[:self.curx]
         cury = self.cury
         while True:
             cury -= 1
             if cury <= 0:
                 break
             if self.history[cury].startswith(prefix):
                 self.input = self.history[self.cury]
                 self.cury = cury
                 return True
         curses.beep()
 
     def cmd_exit(self, browser):
         browser.mode = "default"
         return True
 
     def cmd_execute(self, browser):
         raise NotImplementedError
 
 
 class _CommandGoto(_CommandInput):
     def __init__(self):
         _CommandInput.__init__(self, "goto object #")
 
     def handlechar(self, browser, char):
         # Only accept digits
         if not "0" <= char <= "9":
             curses.beep()
         else:
             return _CommandInput.handlechar(self, browser, char)
 
     def cmd_execute(self, browser):
         level = browser.levels[-1]
         if self.input:
             self.dohistory()
             level.moveto(level.curx, int(self.input))
         browser.mode = "default"
         return True
 
 
 class _CommandFind(_CommandInput):
     def __init__(self):
         _CommandInput.__init__(self, "find expression")
 
     def cmd_execute(self, browser):
         level = browser.levels[-1]
         if self.input:
             self.dohistory()
             while True:
                 cury = level.cury
                 level.moveto(level.curx, cury+1)
                 if cury == level.cury:
                     curses.beep()
                     break # hit end
                 item = level.items[level.cury].item
                 try:
                     globals = ipipe.getglobals(None)
                     if eval(self.input, globals, ipipe.AttrNamespace(item)):
                         break # found something
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     browser.report(exc)
                     curses.beep()
                     break  # break on error
         browser.mode = "default"
         return True
 
 
 class _CommandFindBackwards(_CommandInput):
     def __init__(self):
         _CommandInput.__init__(self, "find backwards expression")
 
     def cmd_execute(self, browser):
         level = browser.levels[-1]
         if self.input:
             self.dohistory()
             while level.cury:
                 level.moveto(level.curx, level.cury-1)
                 item = level.items[level.cury].item
                 try:
                     globals = ipipe.getglobals(None)
                     if eval(self.input, globals, ipipe.AttrNamespace(item)):
                         break # found something
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     browser.report(exc)
                     curses.beep()
                     break # break on error
             else:
                 curses.beep()
         browser.mode = "default"
         return 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": _CommandGoto(),
         "find": _CommandFind(),
         "findbackwards": _CommandFindBackwards()
     }
 
     # Maps curses key codes to "function" names
     keymap = Keymap()
     keymap.register("quit", "q")
     keymap.register("up", curses.KEY_UP)
     keymap.register("down", curses.KEY_DOWN)
     keymap.register("pageup", curses.KEY_PPAGE)
     keymap.register("pagedown", curses.KEY_NPAGE)
     keymap.register("left", curses.KEY_LEFT)
     keymap.register("right", curses.KEY_RIGHT)
     keymap.register("home", curses.KEY_HOME, "\x01")
     keymap.register("end", curses.KEY_END, "\x05")
     keymap.register("prevattr", "<\x1b")
     keymap.register("nextattr", ">\t")
     keymap.register("pick", "p")
     keymap.register("pickattr", "P")
     keymap.register("pickallattrs", "C")
     keymap.register("pickmarked", "m")
     keymap.register("pickmarkedattr", "M")
     keymap.register("enterdefault", "\r\n")
     # FIXME: What's happening here?
     keymap.register("leave", curses.KEY_BACKSPACE, "x\x08\x7f")
     keymap.register("hideattr", "h")
     keymap.register("unhideattrs", "H")
     keymap.register("help", "?")
     keymap.register("enter", "e")
     keymap.register("enterattr", "E")
     keymap.register("detail", "d")
     keymap.register("detailattr", "D")
     keymap.register("tooglemark", " ")
     keymap.register("markrange", "r")
     keymap.register("sortattrasc", "v")
     keymap.register("sortattrdesc", "V")
     keymap.register("goto", "g")
     keymap.register("find", "f")
     keymap.register("findbackwards", "b")
 
     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"
 
         # set by the SIGWINCH signal handler
         self.resized = False
 
     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, astyle.COLOR_BLUE, 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.prompts[mode].start()
 
     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]
             elif 0x00 < keycode < 0x20:
                 return "CTRL-%s" % chr(keycode + 64)
             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_up(self):
         """
         Move the cursor to the previous row.
         """
         level = self.levels[-1]
         self.report("up")
         level.moveto(level.curx, level.cury-self.stepy)
 
     def cmd_down(self):
         """
         Move the cursor to the next row.
         """
         level = self.levels[-1]
         self.report("down")
         level.moveto(level.curx, level.cury+self.stepy)
 
     def cmd_pageup(self):
         """
         Move the cursor up one page.
         """
         level = self.levels[-1]
         self.report("page up")
         level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
 
     def cmd_pagedown(self):
         """
         Move the cursor down one page.
         """
         level = self.levels[-1]
         self.report("page down")
         level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
 
     def cmd_left(self):
         """
         Move the cursor left.
         """
         level = self.levels[-1]
         self.report("left")
         level.moveto(level.curx-self.stepx, level.cury)
 
     def cmd_right(self):
         """
         Move the cursor right.
         """
         level = self.levels[-1]
         self.report("right")
         level.moveto(level.curx+self.stepx, level.cury)
 
     def cmd_home(self):
         """
         Move the cursor to the first column.
         """
         level = self.levels[-1]
         self.report("home")
         level.moveto(0, level.cury)
 
     def cmd_end(self):
         """
         Move the cursor to the last column.
         """
         level = self.levels[-1]
         self.report("end")
         level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
 
     def cmd_prevattr(self):
         """
         Move the cursor one attribute column to the left.
         """
         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):
         """
         Move the cursor one attribute column to the right.
         """
         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):
         """
         '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.)
+        (In IPython this object will be available as the ``_`` variable.)
         """
         level = self.levels[-1]
         self.returnvalue = level.items[level.cury].item
         return True
 
     def cmd_pickattr(self):
         """
         'Pick' the attribute under the cursor (i.e. the row/column the
         cursor is on).
         """
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no column under cursor"))
             return
-        attr = ipipe._getattr(level.items[level.cury].item, attrname)
-        if attr is ipipe.noitem:
+        value = attr.value(level.items[level.cury].item)
+        if value is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(AttributeError(attr.name()))
         else:
-            self.returnvalue = attr
+            self.returnvalue = value
             return True
 
     def cmd_pickallattrs(self):
         """
         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.
         """
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no column under cursor"))
             return
         result = []
         for cache in level.items:
-            attr = ipipe._getattr(cache.item, attrname)
-            if attr is not ipipe.noitem:
-                result.append(attr)
+            value = attr.value(cache.item)
+            if value is not ipipe.noitem:
+                result.append(value)
         self.returnvalue = result
         return True
 
     def cmd_pickmarked(self):
         """
         'Pick' marked objects. Marked objects will be returned as a list.
         """
         level = self.levels[-1]
         self.returnvalue = [cache.item for cache in level.items if cache.marked]
         return True
 
     def cmd_pickmarkedattr(self):
         """
         'Pick' the attribute under the cursor from all marked objects
         (This returns a list).
         """
 
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no column under cursor"))
             return
         result = []
         for cache in level.items:
             if cache.marked:
-                attr = ipipe._getattr(cache.item, attrname)
-                if attr is not ipipe.noitem:
-                    result.append(attr)
+                value = attr.value(cache.item)
+                if value is not ipipe.noitem:
+                    result.append(value)
         self.returnvalue = result
         return True
 
     def cmd_markrange(self):
         """
         Mark all objects from the last marked object before the current cursor
         position to the cursor position.
         """
         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):
         """
         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
+        itself (i.e. how it implements the ``__xiter__`` method). This opens a new
         browser 'level'.
         """
         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):
         """
         Leave the current browser level and go back to the previous one.
         """
         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):
         """
         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).
         """
         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):
         """
         Enter the attribute under the cursor.
         """
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no column under cursor"))
             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.noitem:
-                self.report(AttributeError(ipipe._attrname(attrname)))
+            value = attr.value(item)
+            name = attr.name()
+            if value is ipipe.noitem:
+                self.report(AttributeError(name))
             else:
-                self.report("entering object attribute %s..." % ipipe._attrname(attrname))
-                self.enter(attr, None)
+                self.report("entering object attribute %s..." % name)
+                self.enter(value, None)
 
     def cmd_detail(self):
         """
         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).
         """
         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")
+            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
+            self.enter(attrs, "detail")
 
     def cmd_detailattr(self):
         """
         Show a detail view of the attribute under the cursor.
         """
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no attribute"))
             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.noitem:
-                self.report(AttributeError(ipipe._attrname(attrname)))
+            try:
+                item = attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                self.report(exc)
             else:
-                self.report("entering detail view for attribute...")
-                self.enter(attr, "detail")
+                self.report("entering detail view for attribute %s..." % attr.name())
+                attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
+                self.enter(attrs, "detail")
 
     def cmd_tooglemark(self):
         """
         Mark/unmark the object under the cursor. Marked objects have a '!'
         after the row number).
         """
         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):
         """
         Sort the objects (in ascending order) using the attribute under
         the cursor as the sort key.
         """
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no column under cursor"))
             return
-        self.report("sort by %s (ascending)" % ipipe._attrname(attrname))
+        self.report("sort by %s (ascending)" % attr.name())
         def key(item):
             try:
-                return ipipe._getattr(item, attrname, None)
+                return attr.value(item)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception:
                 return None
         level.sort(key)
 
     def cmd_sortattrdesc(self):
         """
         Sort the objects (in descending order) using the attribute under
         the cursor as the sort key.
         """
         level = self.levels[-1]
-        attrname = level.displayattr[1]
-        if attrname is ipipe.noitem:
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
             curses.beep()
-            self.report(AttributeError(ipipe._attrname(attrname)))
+            self.report(CommandError("no column under cursor"))
             return
-        self.report("sort by %s (descending)" % ipipe._attrname(attrname))
+        self.report("sort by %s (descending)" % attr.name())
         def key(item):
             try:
-                return ipipe._getattr(item, attrname, None)
+                return attr.value(item)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception:
                 return None
         level.sort(key, reverse=True)
 
     def cmd_hideattr(self):
         """
         Hide the attribute under the cursor.
         """
         level = self.levels[-1]
         if level.displayattr[0] is None:
             self.beep()
         else:
             self.report("hideattr")
             level.hiddenattrs.add(level.displayattr[1])
             level.moveto(level.curx, level.cury, refresh=True)
 
     def cmd_unhideattrs(self):
         """
         Make all attributes visible again.
         """
         level = self.levels[-1]
         self.report("unhideattrs")
         level.hiddenattrs.clear()
         level.moveto(level.curx, level.cury, refresh=True)
 
     def cmd_goto(self):
         """
         Jump to a row. The row number can be entered at the
         bottom of the screen.
         """
         self.startkeyboardinput("goto")
 
     def cmd_find(self):
         """
         Search forward for a row. The search condition can be entered at the
         bottom of the screen.
         """
         self.startkeyboardinput("find")
 
     def cmd_findbackwards(self):
         """
         Search backward for a row. The search condition can be entered at the
         bottom of the screen.
         """
         self.startkeyboardinput("findbackwards")
 
     def cmd_help(self):
         """
         Opens the help screen as a new browser level, describing keyboard
         shortcuts.
         """
         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 cmd_quit(self):
         """
         Quit the browser and return to the IPython prompt.
         """
         self.returnvalue = None
         return True
 
     def sigwinchhandler(self, signal, frame):
         self.resized = True
 
     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 in ("quit", "help"):
             key = self.keymap.findkey(key, None)
             if key is not None:
                 keys.append("%s=quit" % self.keylabel(key))
         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]:
+                for attr in level.displayattrs:
+                    attrname = attr.name()
+                    cwidth = level.colwidths[attr]
+                    header = attrname.ljust(cwidth)
+                    if attr is 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
                             if i == level.cury:
                                 style = self.getstylehere(style)
                         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.noitem and attrname is not None:
+                attr = level.displayattr[1]
+                if attr is not ipipe.noitem and not isinstance(attr, ipipe.SelfDescriptor):
                     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, attr.name(), self.style_footer)
                     posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
                     try:
-                        attr = ipipe._getattr(item, attrname)
+                        value = attr.value(item)
                     except (SystemExit, KeyboardInterrupt):
                         raise
                     except Exception, exc:
                         attr = exc
-                    if attr is not ipipe.noitem:
-                        attrstyle = ipipe.xrepr(attr, "footer")
+                    if value is not ipipe.noitem:
+                        attrstyle = ipipe.xrepr(value, "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:
                     history = self.prompts[self.mode]
                     posx = 0
                     posy = self.scrsizey-1
                     posx += self.addstr(posy, posx, 0, endx, history.prompt, astyle.style_default)
                     posx += self.addstr(posy, posx, 0, endx, " [", astyle.style_default)
                     if history.cury==-1:
                         text = "new"
                     else:
                         text = str(history.cury+1)
                     posx += self.addstr(posy, posx, 0, endx, text, astyle.style_type_number)
                     if history.history:
                         posx += self.addstr(posy, posx, 0, endx, "/", astyle.style_default)
                         posx += self.addstr(posy, posx, 0, endx, str(len(history.history)), astyle.style_type_number)
                     posx += self.addstr(posy, posx, 0, endx, "]: ", astyle.style_default)
                     inputstartx = posx
                     posx += self.addstr(posy, posx, 0, endx, history.input, 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 errors from writing to the last line
                 pass
             scr.clrtoeol()
 
             # Position cursor
             if self.mode in self.prompts:
                 history = self.prompts[self.mode]
                 scr.move(self.scrsizey-1, inputstartx+history.curx)
             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.resized:
                     size = fcntl.ioctl(0, tty.TIOCGWINSZ, "12345678")
                     size = struct.unpack("4H", size)
                     oldsize = scr.getmaxyx()
                     scr.erase()
                     curses.resize_term(size[0], size[1])
                     newsize = scr.getmaxyx()
                     scr.erase()
                     for l in self.levels:
                         l.mainsizey += newsize[0]-oldsize[0]
                         l.moveto(l.curx, l.cury, refresh=True)
                     scr.refresh()
                     self.resized = False
                     break # Redisplay
                 if self.mode in self.prompts:
                     if self.prompts[self.mode].handlekey(self, c):
                        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):
         if hasattr(curses, "resize_term"):
             oldhandler = signal.signal(signal.SIGWINCH, self.sigwinchhandler)
             try:
                 return curses.wrapper(self._dodisplay)
             finally:
                 signal.signal(signal.SIGWINCH, oldhandler)
         else:
             return curses.wrapper(self._dodisplay)

IPython/Extensions/ipipe.py

@@ -1,1853 +1,2121 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 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
 
 import path
 try:
     from IPython import genutils, ipapi
 except ImportError:
     genutils = None
     ipapi = None
 
 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):
     """
     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))
 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.
         """
 
         if isinstance(codestring, basestring):
             code = compile(codestring, "_eval", "eval")
         else:
             code = codestring
         newlocals = {}
         for name in code.co_names:
             try:
                 newlocals[name] = _locals[name]
             except KeyError:
                 pass
         return real_eval(code, _globals, newlocals)
 
 
 noitem = object()
 
 def item(iterator, index, default=noitem):
     """
     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 noitem:
         raise IndexError(index)
     else:
         return default
 
 
 def getglobals(g):
     if g is None:
         if ipapi is not None:
             api = ipapi.get()
             if api is not None:
                 return api.user_ns
         return globals()
     return g
 
 
+class Descriptor(object):
+    def __hash__(self):
+        return hash(self.__class__) ^ hash(self.key())
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__ and self.key() == other.key()
+
+    def __ne__(self, other):
+        return self.__class__ is not other.__class__ or self.key() != other.key()
+
+    def key(self):
+        pass
+
+    def name(self):
+        key = self.key()
+        if key is None:
+            return "_"
+        return str(key)
+
+    def attrtype(self, obj):
+        pass
+
+    def valuetype(self, obj):
+        pass
+
+    def value(self, obj):
+        pass
+
+    def doc(self, obj):
+        pass
+
+    def shortdoc(self, obj):
+        doc = self.doc(obj)
+        if doc is not None:
+            doc = doc.strip().splitlines()[0].strip()
+        return doc
+
+    def iter(self, obj):
+        return xiter(self.value(obj))
+
+
+class SelfDescriptor(Descriptor):
+    def key(self):
+        return None
+
+    def attrtype(self, obj):
+        return "self"
+
+    def valuetype(self, obj):
+        return type(obj)
+
+    def value(self, obj):
+        return obj
+
+    def __repr__(self):
+        return "Self"
+
+selfdescriptor = SelfDescriptor() # there's no need for more than one
+
+
+class AttributeDescriptor(Descriptor):
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        return self._doc
+
+    def attrtype(self, obj):
+        return "attr"
+
+    def valuetype(self, obj):
+        return type(getattr(obj, self._name))
+
+    def value(self, obj):
+        return getattr(obj, self._name)
+
+    def __repr__(self):
+        if self._doc is None:
+            return "Attribute(%r)" % self._name
+        else:
+            return "Attribute(%r, %r)" % (self._name, self._doc)
+
+
+class IndexDescriptor(Descriptor):
+    __slots__ = ("_index",)
+
+    def __init__(self, index):
+        self._index = index
+
+    def key(self):
+        return self._index
+
+    def attrtype(self, obj):
+        return "item"
+
+    def valuetype(self, obj):
+        return type(obj[self._index])
+
+    def value(self, obj):
+        return obj[self._index]
+
+    def __repr__(self):
+        return "Index(%r)" % self._index
+
+
+class MethodDescriptor(Descriptor):
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        if self._doc is None:
+            return getattr(obj, self._name).__doc__
+        return self._doc
+
+    def attrtype(self, obj):
+        return "method"
+
+    def valuetype(self, obj):
+        return type(self.value(obj))
+
+    def value(self, obj):
+        return getattr(obj, self._name)()
+
+    def __repr__(self):
+        if self._doc is None:
+            return "Method(%r)" % self._name
+        else:
+            return "Method(%r, %r)" % (self._name, self._doc)
+
+
+class IterAttributeDescriptor(Descriptor):
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        return self._doc
+
+    def attrtype(self, obj):
+        return "iter"
+
+    def valuetype(self, obj):
+        return noitem
+
+    def value(self, obj):
+        return noitem
+
+    def iter(self, obj):
+        return xiter(getattr(obj, self._name))
+
+    def __repr__(self):
+        if self._doc is None:
+            return "IterAttribute(%r)" % self._name
+        else:
+            return "IterAttribute(%r, %r)" % (self._name, self._doc)
+
+
+class IterMethodDescriptor(Descriptor):
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        if self._doc is None:
+            return getattr(obj, self._name).__doc__
+        return self._doc
+
+    def attrtype(self, obj):
+        return "itermethod"
+
+    def valuetype(self, obj):
+        return noitem
+
+    def value(self, obj):
+        return noitem
+
+    def iter(self, obj):
+        return xiter(getattr(obj, self._name)())
+
+    def __repr__(self):
+        if self._doc is None:
+            return "IterMethod(%r)" % self._name
+        else:
+            return "IterMethod(%r, %r)" % (self._name, self._doc)
+
+
+class FunctionDescriptor(Descriptor):
+    __slots__ = ("_function", "_name", "_doc")
+
+    def __init__(self, function, name=None, doc=None):
+        self._function = function
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._function
+
+    def name(self):
+        if self._name is not None:
+            return self._name
+        return getattr(self._function, "__xname__", self._function.__name__)
+
+    def doc(self, obj):
+        if self._doc is None:
+            return self._function.__doc__
+        return self._doc
+
+    def attrtype(self, obj):
+        return "function"
+
+    def valuetype(self, obj):
+        return type(self._function(obj))
+
+    def value(self, obj):
+        return self._function(obj)
+
+    def __repr__(self):
+        if self._doc is None:
+            return "Function(%r)" % self._name
+        else:
+            return "Function(%r, %r)" % (self._name, self._doc)
+
+
 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=noitem):
-    """
-    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):
+def xrepr(item, mode="default"):
     try:
         func = item.__xrepr__
     except AttributeError:
         pass
     else:
         try:
             for x in func(mode):
                 yield x
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception:
             yield (astyle.style_default, repr(item))
         return
     if item is None:
         yield (astyle.style_type_none, repr(item))
     elif isinstance(item, bool):
         yield (astyle.style_type_bool, repr(item))
     elif isinstance(item, str):
         if mode == "cell":
             yield (astyle.style_default, repr(item.expandtabs(tab))[1:-1])
         else:
             yield (astyle.style_default, repr(item))
     elif isinstance(item, unicode):
         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 (astyle.style_type_number, repr(item))
     elif isinstance(item, datetime.datetime):
         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):
         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):
         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 (astyle.style_type_datetime, repr(item))
+    elif isinstance(item, type):
+        if item.__module__ == "__builtin__":
+            yield (astyle.style_type_type, item.__name__)
+        else:
+            yield (astyle.style_type_type, "%s.%s" % (item.__module__, item.__name__))
     elif isinstance(item, Exception):
         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)):
         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:
             yield (-1, False)
             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)):
         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:
             yield (-1, False)
             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 (astyle.style_default, repr(item))
 
 
-def xattrs(item, mode):
+def upgradexattr(attr):
+    if attr is None:
+        return selfdescriptor
+    elif isinstance(attr, Descriptor):
+        return attr
+    elif isinstance(attr, str):
+        if attr.endswith("()"):
+            if attr.startswith("-"):
+                return IterMethodDescriptor(attr[1:-2])
+            else:
+                return MethodDescriptor(attr[:-2])
+        else:
+            if attr.startswith("-"):
+                return IterAttributeDescriptor(attr[1:])
+            else:
+                return AttributeDescriptor(attr)
+    elif isinstance(attr, (int, long)):
+        return IndexDescriptor(attr)
+    elif callable(attr):
+        return FunctionDescriptor(attr)
+    else:
+        raise TypeError("can't handle descriptor %r" % attr)
+
+
+def xattrs(item, mode="default"):
     try:
         func = item.__xattrs__
     except AttributeError:
         if mode == "detail":
-            return dir(item)
+            for attrname in dir(item):
+                yield AttributeDescriptor(attrname)
         else:
-            return (None,)
+            yield selfdescriptor
     else:
-        try:
-            return func(mode)
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except Exception:
-            return (None,)
+        for attr in func(mode):
+            yield upgradexattr(attr)
 
 
-def xiter(item, mode):
-    if mode == "detail":
-        def items():
-            for name in xattrs(item, mode):
-                yield XAttr(item, name)
-        return items()
+def _isdict(item):
+    try:
+        itermeth = item.__class__.__iter__
+    except (AttributeError, TypeError):
+        return False
+    return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
+
+
+def _isstr(item):
+    if not isinstance(item, basestring):
+        return False
+    try:
+        itermeth = item.__class__.__iter__
+    except AttributeError:
+        return True
+    return False # ``__iter__`` has been redefined
+
+
+def xiter(item, mode="default"):
     try:
         func = item.__xiter__
     except AttributeError:
-        if isinstance(item, (dict, types.DictProxyType)):
+        if _isdict(item):
             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):
+        elif _isstr(item):
+            if not 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):
+    def __iter__(self):
         return itertools.chain(*self.iters)
 
     def __xrepr__(self, mode):
         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 ifile(path.path.getcwd())
     getcwd.__doc__ = path.path.getcwd.__doc__
     getcwd = staticmethod(getcwd)
 
     def abspath(self):
         return ifile(path.path.abspath(self))
     abspath.__doc__ = path.path.abspath.__doc__
 
     def normcase(self):
         return ifile(path.path.normcase(self))
     normcase.__doc__ = path.path.normcase.__doc__
 
     def normpath(self):
         return ifile(path.path.normpath(self))
     normpath.__doc__ = path.path.normpath.__doc__
 
     def realpath(self):
         return ifile(path.path.realpath(self))
     realpath.__doc__ = path.path.realpath.__doc__
 
     def expanduser(self):
         return ifile(path.path.expanduser(self))
     expanduser.__doc__ = path.path.expanduser.__doc__
 
     def expandvars(self):
         return ifile(path.path.expandvars(self))
     expandvars.__doc__ = path.path.expandvars.__doc__
 
     def dirname(self):
         return ifile(path.path.dirname(self))
     dirname.__doc__ = path.path.dirname.__doc__
 
     parent = property(dirname, None, None, path.path.parent.__doc__)
 
     def splitpath(self):
         (parent, child) = path.path.splitpath(self)
         return (ifile(parent), child)
     splitpath.__doc__ = path.path.splitpath.__doc__
 
     def splitdrive(self):
         (drive, rel) = path.path.splitdrive(self)
         return (ifile(drive), rel)
     splitdrive.__doc__ = path.path.splitdrive.__doc__
 
     def splitext(self):
         (filename, ext) = path.path.splitext(self)
         return (ifile(filename), ext)
     splitext.__doc__ = path.path.splitext.__doc__
 
     if hasattr(path.path, "splitunc"):
         def splitunc(self):
             (unc, rest) = path.path.splitunc(self)
             return (ifile(unc), rest)
         splitunc.__doc__ = path.path.splitunc.__doc__
 
         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))
     joinpath.__doc__ = path.path.joinpath.__doc__
 
     def splitall(self):
         return map(ifile, path.path.splitall(self))
     splitall.__doc__ = path.path.splitall.__doc__
 
     def relpath(self):
         return ifile(path.path.relpath(self))
     relpath.__doc__ = path.path.relpath.__doc__
 
     def relpathto(self, dest):
         return ifile(path.path.relpathto(self, dest))
     relpathto.__doc__ = path.path.relpathto.__doc__
 
     def listdir(self, pattern=None):
         return [ifile(child) for child in path.path.listdir(self, pattern)]
     listdir.__doc__ = path.path.listdir.__doc__
 
     def dirs(self, pattern=None):
         return [ifile(child) for child in path.path.dirs(self, pattern)]
     dirs.__doc__ = path.path.dirs.__doc__
 
     def files(self, pattern=None):
         return [ifile(child) for child in path.path.files(self, pattern)]
     files.__doc__ = path.path.files.__doc__
 
     def walk(self, pattern=None):
         for child in path.path.walk(self, pattern):
             yield ifile(child)
     walk.__doc__ = path.path.walk.__doc__
 
     def walkdirs(self, pattern=None):
         for child in path.path.walkdirs(self, pattern):
             yield ifile(child)
     walkdirs.__doc__ = path.path.walkdirs.__doc__
 
     def walkfiles(self, pattern=None):
         for child in path.path.walkfiles(self, pattern):
             yield ifile(child)
     walkfiles.__doc__ = path.path.walkfiles.__doc__
 
     def glob(self, pattern):
         return map(ifile, path.path.glob(self, pattern))
     glob.__doc__ = path.path.glob.__doc__
 
     if hasattr(os, 'readlink'):
         def readlink(self):
             return ifile(path.path.readlink(self))
         readlink.__doc__ = path.path.readlink.__doc__
 
         def readlinkabs(self):
             return ifile(path.path.readlinkabs(self))
         readlinkabs.__doc__ = path.path.readlinkabs.__doc__
 
     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):
+    def mimetype(self):
+        """
+        Return MIME type guessed from the extension.
+        """
         return mimetypes.guess_type(self.basename())[0]
-    mimetype = property(getmimetype, None, None, "MIME type")
 
-    def getencoding(self):
+    def encoding(self):
+        """
+        Return guessed compression (like "compress" or "gzip").
+        """
         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"
+                "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()",
+                "-listdir()",
+                "-dirs()",
+                "-files()",
+                "-walk()",
+                "-walkdirs()",
+                "-walkfiles()",
             )
-        return self.defaultattrs
+        else:
+            return (None, "type", "size", "modestr", "owner", "group", "mdate")
 
     def __xrepr__(self, mode):
         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):
+    def __iter__(self):
         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):
         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 __iter__(self):
+        return xiter(ifile(self.base))
 
     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):
+    def __iter__(self):
         for name in glob.glob(self.glob):
             yield ifile(name)
 
     def __xrepr__(self, mode):
         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):
+    def __iter__(self):
         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):
         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")
+       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):
         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):
         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):
+    def __iter__(self):
         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):
+    def __iter__(self):
         for entry in grp.getgrall():
             yield igrpentry(entry.gr_name)
 
     def __xrepr__(self, mode):
         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
+        self.__fieldnames = [upgradexattr(fieldname) for fieldname in 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, f.name())
                 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, f.name())
             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):
+    def __iter__(self):
         fields = ("key", "value")
         for (key, value) in os.environ.iteritems():
             yield Fields(fields, key=key, value=value)
 
     def __xrepr__(self, mode):
         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):
+    def __iter__(self):
         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._pipeout = None
 
-    def __xiter__(self, mode="default"):
+    def __iter__(self):
         (_pipein, self._pipeout) = os.popen4(self.cmd)
         _pipein.close()
         for l in self._pipeout:
             yield l.rstrip("\r\n")
         self._pipeout.close()
         self._pipeout = None
 
     def __del__(self):
         if self._pipeout is not None and not self._pipeout.closed:
             self._pipeout.close()
         self._pipeout = None
 
     def __xrepr__(self, mode):
         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, globals=None, errors="raiseifallfail"):
         """
         Create an ``ifilter`` object. ``expr`` can be a callable or a string
         containing an expression. ``globals`` will be used as the global
         namespace for calling string expressions (defaulting to IPython's
         user namespace). ``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.globals = globals
         self.errors = errors
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         if callable(self.expr):
             test = self.expr
         else:
             g = getglobals(self.globals)
             expr = compile(self.expr, "ipipe-expression", "eval")
             def test(item):
                 return eval(expr, g, AttrNamespace(item))
 
         ok = 0
         exc_info = None
-        for item in xiter(self.input, mode):
+        for item in xiter(self.input):
             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):
         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, globals=None, errors="raiseifallfail"):
         """
         Create an ``ieval`` object. ``expr`` can be a callable or a string
         containing an expression. For the meaning of ``globals`` and
         ``errors`` see ``ifilter``.
         """
         self.expr = expr
         self.globals = globals
         self.errors = errors
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         if callable(self.expr):
             do = self.expr
         else:
             g = getglobals(self.globals)
             expr = compile(self.expr, "ipipe-expression", "eval")
             def do(item):
                 return eval(expr, g, AttrNamespace(item))
 
         ok = 0
         exc_info = None
-        for item in xiter(self.input, mode):
+        for item in xiter(self.input):
             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):
         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):
+    def __iter__(self):
         fields = ("index", "object")
-        for (index, object) in enumerate(xiter(self.input, mode)):
+        for (index, object) in enumerate(xiter(self.input)):
             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=None, globals=None, reverse=False):
         """
         Create an ``isort`` object. ``key`` can be a callable or a string
         containing an expression (or ``None`` in which case the items
         themselves will be sorted). If ``reverse`` is true the sort order
         will be reversed. For the meaning of ``globals`` see ``ifilter``.
         """
         self.key = key
         self.globals = globals
         self.reverse = reverse
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         if self.key is None:
-            items = sorted(
-                xiter(self.input, mode),
-                reverse=self.reverse
-            )
+            items = sorted(xiter(self.input), reverse=self.reverse)
         elif callable(self.key):
-            items = sorted(
-                xiter(self.input, mode),
-                key=self.key,
-                reverse=self.reverse
-            )
+            items = sorted(xiter(self.input), key=self.key, reverse=self.reverse)
         else:
             g = getglobals(self.globals)
             key = compile(self.key, "ipipe-expression", "eval")
             def realkey(item):
                 return eval(key, g, AttrNamespace(item))
             items = sorted(
                 xiter(self.input, mode),
                 key=realkey,
                 reverse=self.reverse
             )
         for item in items:
             yield item
 
     def __xrepr__(self, mode):
         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]
+                    attrs = tuple(_upgradexattrs(item, "default"))
+                    attrs = ["%s=%s" % (a.name(item), a.value(item)) 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 = True
     width = 0
     text = astyle.Text()
     for (style, part) in xrepr(value, mode):
         # only consider the first result
         if align is None:
             if isinstance(style, int):
                 # (style, text) really is (alignment, stop)
                 align = style
                 full = part
                 continue
             else:
                 align = -1
                 full = True
         if not isinstance(style, int):
             text.append((style, part))
             width += len(part)
             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.attrs = [upgradexattr(attr) for attr in attrs]
         self.headerpadchar = " "
         self.headersepchar = "|"
         self.datapadchar = " "
         self.datasepchar = "|"
 
     def display(self):
         stream = genutils.Term.cout
         allattrs = []
-        allattrset = set()
+        attrset = 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))
+            for attr in attrs:
+                if attr not in attrset:
+                    allattrs.append(attr)
+                    attrset.add(attr)
+                    colwidths[attr] = len(attr.name())
                 try:
-                    value = _getattr(item, attrname, None)
+                    value = attr.value(item)
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     value = exc
                 (align, width, text) = xformat(value, "cell", self.maxattrlength)
-                colwidths[attrname] = max(colwidths[attrname], width)
+                colwidths[attr] = max(colwidths[attr], width)
                 # remember alignment, length and colored parts
-                row[attrname] = (align, width, text)
+                row[attr] = (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))
+        for (i, attr) in enumerate(allattrs):
+            attrname = attr.name()
+            self.style_header(attrname).write(stream)
+            spc = colwidths[attr] - len(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
+            for (i, attr) in enumerate(allattrs):
+                (align, width, text) = row[attr]
+                spc = colwidths[attr] - width
                 if align == -1:
                     text.write(stream)
                     if i < len(colwidths)-1:
                         stream.write(self.datapadchar*spc)
                 elif align == 0:
-                    spc = colwidths[attrname] - width
+                    spc = colwidths[attr] - 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):
         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")
+        else:
             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)
+class AttributeDetail(Table):
+    def __init__(self, object, descriptor):
+        self.object = object
+        self.descriptor = descriptor
 
-        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__)
+    def __iter__(self):
+        return self.descriptor.iter(self.object)
 
-        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 name(self):
+        return self.descriptor.name()
+
+    def attrtype(self):
+        return self.descriptor.attrtype(self.object)
+
+    def valuetype(self):
+        return self.descriptor.valuetype(self.object)
+
+    def doc(self):
+        return self.descriptor.doc(self.object)
+
+    def shortdoc(self):
+        return self.descriptor.shortdoc(self.object)
+
+    def value(self):
+        return self.descriptor.value(self.object)
 
     def __xattrs__(self, mode):
-        return ("name", "type", "doc", "value")
+        attrs = ("name()", "attrtype()", "valuetype()", "value()", "shortdoc()")
+        if mode == "detail":
+            attrs += ("doc()",)
+        return attrs
+
+    def __xrepr__(self, mode):
+        yield (-1, True)
+        yield (astyle.style_default, self.attrtype())
+        yield (astyle.style_default, "(")
+        for part in xrepr(self.valuetype()):
+            yield part
+        yield (astyle.style_default, ") ")
+        yield (astyle.style_default, self.name())
+        yield (astyle.style_default, " of ")
+        for part in xrepr(self.object):
+            yield part
 
 
 try:
     from ibrowse import ibrowse
 except ImportError:
     # No curses (probably Windows) => use ``idump`` as the default display.
     defaultdisplay = idump
 else:
     defaultdisplay = ibrowse
     __all__.append("ibrowse")
 
 
 # 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
 api = None
 if ipapi is not None:
     try:
         api = ipapi.get()
     except AttributeError:
         pass
 
 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()