* 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

@@ -374,6 +374,7 b' 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")

IPython/Extensions/ibrowse.py

@@ -97,7 +97,7 b' class _BrowserHelp(object):'
         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():
@@ -125,7 +125,7 b' class _BrowserHelp(object):'
                 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])
@@ -183,13 +183,13 b' class _BrowserLevel(object):'
         # 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
@@ -207,6 +207,13 b' class _BrowserLevel(object):'
             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))
@@ -215,22 +222,23 b' class _BrowserLevel(object):'
         # 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
@@ -239,9 +247,9 b' class _BrowserLevel(object):'
         # 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:
@@ -249,7 +257,7 b' class _BrowserLevel(object):'
             # 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):
@@ -260,16 +268,16 b' class _BrowserLevel(object):'
         # 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))
@@ -282,11 +290,11 b' class _BrowserLevel(object):'
         # 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)
 
@@ -1030,7 +1038,7 b' class ibrowse(ipipe.Display):'
         """
         '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
@@ -1042,17 +1050,17 b' class ibrowse(ipipe.Display):'
         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):
@@ -1062,16 +1070,16 b' class ibrowse(ipipe.Display):'
         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
 
@@ -1090,17 +1098,17 b' class ibrowse(ipipe.Display):'
         """
 
         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
 
@@ -1130,7 +1138,7 b' class ibrowse(ipipe.Display):'
     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]
@@ -1176,10 +1184,10 b' class ibrowse(ipipe.Display):'
         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
@@ -1187,12 +1195,13 b' class ibrowse(ipipe.Display):'
             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):
         """
@@ -1209,17 +1218,18 b' class ibrowse(ipipe.Display):'
             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
@@ -1227,12 +1237,16 b' class ibrowse(ipipe.Display):'
             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):
         """
@@ -1259,15 +1273,15 b' class ibrowse(ipipe.Display):'
         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:
@@ -1280,15 +1294,15 b' class ibrowse(ipipe.Display):'
         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:
@@ -1427,11 +1441,11 b' class ibrowse(ipipe.Display):'
                 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
@@ -1527,19 +1541,19 b' class ibrowse(ipipe.Display):'
                             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)

IPython/Extensions/ipipe.py

@@ -269,6 +269,251 b' def getglobals(g):'
     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
@@ -350,47 +595,7 b' class Pipe(Table):'
         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:
@@ -449,6 +654,11 b' def xrepr(item, mode):'
             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__
@@ -514,33 +724,67 b' def xrepr(item, mode):'
         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:
+        for attr in func(mode):
+            yield upgradexattr(attr)
+
+
+def _isdict(item):
         try:
-            return func(mode)
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except Exception:
-            return (None,)
+        itermeth = item.__class__.__iter__
+    except (AttributeError, TypeError):
+        return False
+    return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
 
 
-def xiter(item, mode):
-    if mode == "detail":
-        def items():
-            for name in xattrs(item, mode):
-                yield XAttr(item, name)
-        return items()
+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():
@@ -552,8 +796,8 b' def xiter(item, mode):'
                 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:
@@ -572,7 +816,7 b' class ichain(Pipe):'
     def __init__(self, *iters):
         self.iters = iters
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         return itertools.chain(*self.iters)
 
     def __xrepr__(self, mode):
@@ -823,30 +1067,61 b' class ifile(path.path):'
         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:
@@ -872,7 +1147,7 b' class ifile(path.path):'
         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()):
@@ -906,8 +1181,8 b' class ils(Table):'
     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)
@@ -929,7 +1204,7 b' class iglob(Table):'
     def __init__(self, glob):
         self.glob = glob
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         for name in glob.glob(self.glob):
             yield ifile(name)
 
@@ -958,7 +1233,7 b' class iwalk(Table):'
         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):
@@ -1115,7 +1390,7 b' class igrpentry(object):'
         else:
             yield (astyle.style_default, repr(self))
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         for member in self.mem:
             yield ipwdentry(member)
 
@@ -1128,7 +1403,7 b' 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)
 
@@ -1141,7 +1416,7 b' class igrp(Table):'
 
 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)
 
@@ -1156,7 +1431,7 b' class Fields(object):'
             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
@@ -1167,7 +1442,7 b' class Fields(object):'
             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))
@@ -1182,9 +1457,6 b' class FieldTable(Table, list):'
     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":
@@ -1232,7 +1504,7 b' class ienv(Table):'
         >>> 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)
@@ -1256,7 +1528,7 b' class icsv(Pipe):'
         """
         self.csvargs = csvargs
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         input = self.input
         if isinstance(input, ifile):
             input = input.open("rb")
@@ -1304,7 +1576,7 b' class ix(Table):'
         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:
@@ -1364,7 +1636,7 b' class ifilter(Pipe):'
         self.globals = globals
         self.errors = errors
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         if callable(self.expr):
             test = self.expr
         else:
@@ -1375,7 +1647,7 b' class ifilter(Pipe):'
 
         ok = 0
         exc_info = None
-        for item in xiter(self.input, mode):
+        for item in xiter(self.input):
             try:
                 if test(item):
                     yield item
@@ -1437,7 +1709,7 b' class ieval(Pipe):'
         self.globals = globals
         self.errors = errors
 
-    def __xiter__(self, mode):
+    def __iter__(self):
         if callable(self.expr):
             do = self.expr
         else:
@@ -1448,7 +1720,7 b' class ieval(Pipe):'
 
         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):
@@ -1497,9 +1769,9 b' class ienum(Pipe):'
 
         >>> 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)
 
 
@@ -1524,18 +1796,11 b' class isort(Pipe):'
         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")
@@ -1613,8 +1878,8 b' class iless(Display):'
             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:
@@ -1659,7 +1924,7 b' class idump(Display):'
     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 = " "
@@ -1668,7 +1933,7 b' class idump(Display):'
     def display(self):
         stream = genutils.Term.cout
         allattrs = []
-        allattrset = set()
+        attrset = set()
         colwidths = {}
         rows = []
         for item in xiter(self.input, "default"):
@@ -1676,42 +1941,43 b' class idump(Display):'
             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)
@@ -1755,55 +2021,57 b' class XMode(object):'
 
     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:

doc/ChangeLog

@@ -3,6 +3,27 b''
 	* IPython/Extensions/ipipe.py: Fix getglobals() if we're
 	not running under IPython.
 
+	* 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.
+
 2006-07-26  Ville Vainio  <[e-mail]>
 
 	* iplib.py: history now stores multiline input as single