ipipe patch

IPython/Extensions/ipipe.py

@@ -1,2178 +1,2183 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:
 
    iwalk | ifilter("name.endswith('.py')") | isort("size")
 
 This gives a listing of all files in the current directory (and subdirectories)
 whose name ends with '.py' sorted by size.
 
 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.
 """
 
 import sys, os, os.path, stat, glob, new, csv, datetime
 import textwrap, itertools, mimetypes
 
 try: # Python 2.3 compatibility
     import collections
 except ImportError:
     deque = list
 else:
     deque = collections.deque
 
 try: # Python 2.3 compatibility
     set
 except NameError:
     import sets
     set = sets.Set
 
 try: # Python 2.3 compatibility
     sorted
 except NameError:
     def sorted(iterator, key=None, reverse=False):
         items = list(iterator)
         if key is not None:
             items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
         else:
             items.sort()
         if reverse:
             items.reverse()
         return items
 
 try:
     import pwd
 except ImportError:
     pwd = None
 
 try:
     import grp
 except ImportError:
     grp = None
 
 try:
     import curses
 except ImportError:
     curses = None
 
 
 __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
 
 
 _default = object()
 
 def item(iterator, index, default=_default):
     """
     Return the ``index``th item from the iterator ``iterator``.
     ``index`` must be an integer (negative integers are relative to the
     end (i.e. the last item produced by the iterator)).
 
     If ``default`` is given, this will be the default value when
     the iterator doesn't contain an item at this position. Otherwise an
     ``IndexError`` will be raised.
 
     Note that using this function will partially or totally exhaust the
     iterator.
     """
     i = index
     if i>=0:
         for item in iterator:
             if not i:
                 return item
             i -= 1
     else:
         i = -index
         cache = deque()
         for item in iterator:
             cache.append(item)
             if len(cache)>i:
                 cache.popleft()
         if len(cache)==i:
             return cache.popleft()
     if default is _default:
         raise IndexError(index)
     else:
         return default
 
 
 class _AttrNamespace(object):
     """
     Internal helper that is used for providing a namespace for evaluating
     expressions containg 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)
 
 
 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).
     """
     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):
         if isinstance(other, type) and issubclass(other, (Table, Display)):
             other = other()
         elif not isinstance(other, Display) and not isinstance(other, Table):
             other = ieval(other)
         return other.__ror__(self)
 
     def __add__(self, other):
         if isinstance(other, type) and issubclass(other, Table):
             other = other()
         return ichain(self, other)
 
     def __radd__(self, other):
         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):
         if isinstance(input, type) and issubclass(input, Table):
             input = input()
         self.input = input
         return self
 
 
 def _getattr(obj, name, default=_default):
     """
     Internal helper for getting an attribute of an item. If ``name`` is ``None``
     return the object itself. If ``name`` is an integer, use ``__getitem__``
     instead. If the attribute or item does not exist, return ``default``.
     """
     if name is None:
         return obj
     elif isinstance(name, basestring):
         return getattr(obj, name, default)
     elif callable(name):
         return name(obj)
     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 name.__name__
     else:
         return str(name)
 
 
 def xrepr(item, mode):
     try:
         func = item.__xrepr__
     except (KeyboardInterrupt, SystemExit):
         raise
     except Exception:
         return repr(item)
     else:
         return func(mode)
 
 
 def xattrs(item, mode):
     try:
         func = item.__xattrs__
     except AttributeError:
         if isinstance(item, (list, tuple)):
             return xrange(len(item))
         return (None,)
     else:
         return func(mode)
 
 
 def xiter(item, mode):
     if mode == "detail":
         def items():
             for name in xattrs(item, mode):
                 yield XAttr(item, name)
         return items()
     try:
         func = item.__xiter__
     except AttributeError:
         if isinstance(item, dict):
-            return xiter(idict(item), mode)
+            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 idictentry(key, getattr(item, key))
+                    yield Fields(fields, key, getattr(item, key))
             return items(item)
         elif isinstance(item, basestring):
             if not len(item):
                 raise ValueError("can't enter empty string")
             lines = item.splitlines()
             if len(lines) <= 1:
                 raise ValueError("can't enter one line string")
             return iter(lines)
         return iter(item)
     else:
         return iter(func(mode)) # iter() just to be safe
 
 
 class ichain(Pipe):
     """
     Chains multiple ``Table``s into one.
     """
 
     def __init__(self, *iters):
         self.iters = iters
 
     def __xiter__(self, mode):
         return itertools.chain(*self.iters)
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             parts = []
             for item in self.iters:
                 part = xrepr(item, mode)
                 if isinstance(item, Pipe):
                     part = "(%s)" % part
                 parts.append(part)
             return "+".join(parts)
         return 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(object):
     __slots__ = ("name", "_abspath", "_realpath", "_stat", "_lstat")
 
     def __init__(self, name):
         if isinstance(name, ifile): # copying files
             self.name = name.name
             self._abspath = name._abspath
             self._realpath = name._realpath
             self._stat = name._stat
             self._lstat = name._lstat
         else:
             self.name = os.path.normpath(name)
             self._abspath = None
             self._realpath = None
             self._stat = None
             self._lstat = None
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.name)
 
     def open(self, mode="rb", buffer=None):
         if buffer is None:
             return open(self.abspath, mode)
         else:
             return open(self.abspath, mode, buffer)
 
     def remove(self):
         os.remove(self.abspath)
 
     def getabspath(self):
         if self._abspath is None:
             self._abspath = os.path.abspath(self.name)
         return self._abspath
     abspath = property(getabspath, None, None, "Path to file")
 
     def getrealpath(self):
         if self._realpath is None:
             self._realpath = os.path.realpath(self.name)
         return self._realpath
     realpath = property(getrealpath, None, None, "Path with links resolved")
 
     def getbasename(self):
         return os.path.basename(self.abspath)
     basename = property(getbasename, None, None, "File name without directory")
 
     def getstat(self):
         if self._stat is None:
             self._stat = os.stat(self.abspath)
         return self._stat
     stat = property(getstat, None, None, "os.stat() result")
 
     def getlstat(self):
         if self._lstat is None:
             self._lstat = os.lstat(self.abspath)
         return self._lstat
     lstat = property(getlstat, None, None, "os.lstat() result")
 
     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")
 
     def getaccess(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])
 
     access = property(getaccess, None, None, "Access mode as string")
 
     def getsize(self):
         return int(self.stat.st_size)
     size = property(getsize, None, None, "File size in bytes")
 
     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):
         try:
             return pwd.getpwuid(self.stat.st_uid).pw_name
         except KeyError:
             return self.stat.st_uid
     owner = property(getowner, None, None, "Owner name (or id)")
 
     def getgroup(self):
         try:
             return grp.getgrgid(self.stat.st_gid).gr_name
         except KeyError:
             return self.stat.st_gid
     group = property(getgroup, None, None, "Group name (or id)")
 
     def getatime(self):
         return self.stat.st_atime
     atime = property(getatime, None, None, "Access date")
 
     def getadate(self):
         return datetime.datetime.utcfromtimestamp(self.atime)
     adate = property(getadate, None, None, "Access date")
 
     def getctime(self):
         return self.stat.st_ctime
     ctime = property(getctime, None, None, "Creation date")
 
     def getcdate(self):
         return datetime.datetime.utcfromtimestamp(self.ctime)
     cdate = property(getcdate, None, None, "Creation date")
 
     def getmtime(self):
         return self.stat.st_mtime
     mtime = property(getmtime, None, None, "Modification date")
 
     def getmdate(self):
         return datetime.datetime.utcfromtimestamp(self.mtime)
     mdate = property(getmdate, None, None, "Modification date")
 
     def getmimetype(self):
         return mimetypes.guess_type(self.basename)[0]
     mimetype = property(getmimetype, None, None, "MIME type")
 
     def getencoding(self):
         return mimetypes.guess_type(self.basename)[1]
     encoding = property(getencoding, None, None, "Compression")
 
     def getisdir(self):
         return os.path.isdir(self.abspath)
     isdir = property(getisdir, None, None, "Is this a directory?")
 
     def getislink(self):
         return os.path.islink(self.abspath)
     islink = property(getislink, None, None, "Is this a link?")
 
     def __eq__(self, other):
         return self.abspath == other.abspath
 
     def __neq__(self, other):
         return self.abspath != other.abspath
 
     def __xattrs__(self, mode):
         if mode == "detail":
             return (
                 "name", "basename", "abspath", "realpath",
                 "mode", "type", "access", "stat", "lstat",
                 "uid", "gid", "owner", "group", "dev", "nlink",
                 "ctime", "mtime", "atime", "cdate", "mdate", "adate",
                 "size", "blocks", "blksize", "isdir", "islink",
                 "mimetype", "encoding"
             )
         return ("type", "access", "owner", "group", "mdate", "size", "name")
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             name = "ifile"
             try:
                 if self.isdir:
                     name = "idir"
             except IOError:
                 pass
             return "%s(%r)" % (name, self.abspath)
         return repr(self)
 
     def __xiter__(self, mode):
         if self.isdir:
             abspath = self.abspath
             if abspath != os.path.abspath(os.path.join(abspath, os.pardir)):
                 yield iparentdir(abspath)
             for name in sorted(os.listdir(abspath), key=lambda n: n.lower()):
                 if self.name != os.curdir:
                     name = os.path.join(abspath, name)
                 yield ifile(name)
         else:
             f = self.open("rb")
             for line in f:
                 yield line
             f.close()
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.abspath)
 
 
 class iparentdir(ifile):
     def __init__(self, base):
         self._base = base
         self.name = os.pardir
         self._abspath = None
         self._realpath = None
         self._stat = None
         self._lstat = None
 
     def getabspath(self):
         if self._abspath is None:
             self._abspath = os.path.abspath(os.path.join(self._base, self.name))
         return self._abspath
     abspath = property(getabspath, None, None, "Path to file")
 
     def getrealpath(self):
         if self._realpath is None:
             self._realpath = os.path.realpath(
                 os.path.join(self._base, self.name))
         return self._realpath
     realpath = property(getrealpath, None, None, "Path with links resolved")
 
 
 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 __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "idir(%r)" % (os.path.abspath(self.base))
         return repr(self)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.base)
 
 
 class iglob(Table):
     def __init__(self, glob):
         self.glob = glob
 
     def __xiter__(self, mode):
         for name in glob.glob(self.glob):
             yield ifile(name)
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "%s(%r)" % (self.__class__.__name__, self.glob)
         return repr(self)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.glob)
 
 
 class iwalk(Table):
     def __init__(self, base=os.curdir, dirs=True, files=True):
         self.base = os.path.expanduser(base)
         self.dirs = dirs
         self.files = files
 
     def __xiter__(self, mode):
         for (dirpath, dirnames, filenames) in os.walk(self.base):
             if self.dirs:
                 for name in sorted(dirnames):
                     yield ifile(os.path.join(dirpath, name))
             if self.files:
                 for name in sorted(filenames):
                     yield ifile(os.path.join(dirpath, name))
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "%s(%r)" % (self.__class__.__name__, self.base)
         return repr(self)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.base)
 
 
 class ipwdentry(object):
     def __init__(self, id):
         self._id = id
         self._entry = None
 
     def _getentry(self):
         if self._entry is None:
             if isinstance(self._id, basestring):
                 self._entry = pwd.getpwnam(self._id)
             else:
                 self._entry = pwd.getpwuid(self._id)
         return self._entry
 
     def getname(self):
         if isinstance(self._id, basestring):
             return self._id
         else:
             return self._getentry().pw_name
     name = property(getname, None, None, "User name")
 
     def getpasswd(self):
         return self._getentry().pw_passwd
     passwd = property(getpasswd, None, None, "Password")
 
     def getuid(self):
         if isinstance(self._id, basestring):
             return self._getentry().pw_uid
         else:
             return self._id
     uid = property(getuid, None, None, "User id")
 
     def getgid(self):
         return self._getentry().pw_gid
     gid = property(getgid, None, None, "Primary group id")
 
     def getgroup(self):
         return igrpentry(self.gid)
     group = property(getgroup, None, None, "Group")
 
     def getgecos(self):
         return self._getentry().pw_gecos
     gecos = property(getgecos, None, None, "Information (e.g. full user name)")
 
     def getdir(self):
         return self._getentry().pw_dir
     dir = property(getdir, None, None, "$HOME directory")
 
     def getshell(self):
         return self._getentry().pw_shell
     shell = property(getshell, None, None, "Login shell")
 
     def __xattrs__(self, mode):
         return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self._id)
 
 
 class ipwd(Table):
     def __iter__(self):
         for entry in pwd.getpwall():
             yield ipwdentry(entry.pw_name)
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "%s()" % self.__class__.__name__
         return repr(self)
 
 
 class igrpentry(object):
     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":
             return "group %s" % self.name
         return repr(self)
 
     def __xiter__(self, mode):
         for member in self.mem:
             yield ipwdentry(member)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self._id)
 
 
 class igrp(Table):
     def __xiter__(self, mode):
         for entry in grp.getgrall():
             yield igrpentry(entry.gr_name)
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "%s()" % self.__class__.__name__
         return repr(self)
 
 
 class Fields(object):
     def __init__(self, fieldnames, **fields):
         self.__fieldnames = fieldnames
         for (key, value) in fields.iteritems():
             setattr(self, key, value)
 
     def __xattrs__(self, mode):
         return self.__fieldnames
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             args = ["%s=%r" % (f, getattr(self, f)) for f in self.__fieldnames]
             return "%s(%r)" % (self.__class__.__name__, ", ".join(args))
         return repr(self)
 
 
 class FieldTable(Table, list):
     def __init__(self, *fields):
         ipipe.Table.__init__(self)
         list.__init__(self)
         self.fields = fields
 
     def add(self, **fields):
         self.append(Fields(self, **fields))
 
     def __xiter__(self, mode):
         return list.__iter__(self)
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "FieldTable(%r)" % ", ".join(map(repr, self.fields))
         return 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 ienv(Table):
     def __xiter__(self, mode):
         fields = ("key", "value")
         for (key, value) in os.environ.iteritems():
             yield Fields(fields, key=key, value=value)
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "%s()" % self.__class__.__name__
         return repr(self)
 
 
 class icsv(Pipe):
     def __init__(self, **csvargs):
         self.csvargs = csvargs
 
     def __xiter__(self, mode):
         input = self.input
         if isinstance(input, ifile):
             input = input.open("rb")
         reader = csv.reader(input, **self.csvargs)
         for line in reader:
             yield line
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 prefix = "%s | " % xrepr(input, mode)
             else:
                 prefix = ""
             args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
             return "%s%s(%s)" % (prefix, self.__class__.__name__, args)
         return 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):
     def __init__(self, cmd):
         self.cmd = cmd
         self._pipe = None
 
     def __xiter__(self, mode):
         self._pipe = os.popen(self.cmd)
         for l in self._pipe:
             yield l.rstrip("\r\n")
         self._pipe.close()
         self._pipe = None
 
     def __del__(self):
         if self._pipe is not None and not self._pipe.closed:
             self._pipe.close()
         self._pipe = None
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             return "%s(%r)" % (self.__class__.__name__, self.cmd)
         return repr(self)
 
     def __repr__(self):
         return "%s.%s(%r)" % \
             (self.__class__.__module__, self.__class__.__name__, self.cmd)
 
 
 class ifilter(Pipe):
     def __init__(self, expr):
         self.expr = expr
 
     def __xiter__(self, mode):
         if callable(self.expr):
             for item in xiter(self.input, mode):
                 try:
                     if self.expr(item):
                         yield item
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception:
                     pass # Ignore errors
         else:
             for item in xiter(self.input, mode):
                 try:
                     if eval(self.expr, globals(), _AttrNamespace(item)):
                         yield item
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception:
                     pass # Ignore errors
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 prefix = "%s | " % xrepr(input, mode)
             else:
                 prefix = ""
             return "%s%s(%s)"% \
                 (prefix, self.__class__.__name__, xrepr(self.expr, mode))
         return 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):
     def __init__(self, expr):
         self.expr = expr
 
     def __xiter__(self, mode):
         if callable(self.expr):
             for item in xiter(self.input, mode):
                 try:
                     yield self.expr(item)
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception:
                     pass # Ignore errors
         else:
             for item in xiter(self.input, mode):
                 try:
                     yield eval(self.expr, globals(), _AttrNamespace(item))
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception:
                     pass # Ignore errors
 
     def __xrepr__(self, mode):
         if mode == "header" or mode == "footer":
             input = getattr(self, "input", None)
             if input is not None:
                 prefix = "%s | " % xrepr(input, mode)
             else:
                 prefix = ""
             return "%s%s(%s)" % \
                 (prefix, self.__class__.__name__, xrepr(self.expr, mode))
         return 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):
     def __xiter__(self, mode):
         fields = ("index", "object")
         for (index, object) in enumerate(xiter(self.input, mode)):
             yield Fields(fields, index=index, object=object)
 
 
 class isort(Pipe):
     def __init__(self, key, reverse=False):
         self.key = key
         self.reverse = reverse
 
     def __xiter__(self, mode):
         if callable(self.key):
             items = sorted(
                 xiter(self.input, mode),
                 key=self.key,
                 reverse=self.reverse
             )
         else:
             def key(item):
                 return eval(self.key, globals(), _AttrNamespace(item))
             items = sorted(
                 xiter(self.input, mode),
                 key=key,
                 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:
                 prefix = "%s | " % xrepr(input, mode)
             else:
                 prefix = ""
             if self.reverse:
                 return "%s%s(%r, %r)" % \
                     (prefix, self.__class__.__name__, self.key, self.reverse)
             else:
                 return "%s%s(%r)" % (prefix, self.__class__.__name__, self.key)
         return repr(self)
 
     def __repr__(self):
         return "<%s.%s key=%r reverse=%r at 0x%x>" % \
             (self.__class__.__module__, self.__class__.__name__,
              self.key, self.reverse, id(self))
 
 
 tab = 3 # for expandtabs()
 
 def _format(field):
     if isinstance(field, str):
         text = repr(field.expandtabs(tab))[1:-1]
     elif isinstance(field, unicode):
         text = repr(field.expandtabs(tab))[2:-1]
     elif isinstance(field, datetime.datetime):
         # Don't use strftime() here, as this requires year >= 1900
         text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
             (field.year, field.month, field.day,
              field.hour, field.minute, field.second, field.microsecond)
     elif isinstance(field, datetime.date):
         text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
     else:
         text = repr(field)
     return text
 
 
 class Display(object):
     class __metaclass__(type):
         def __ror__(self, input):
             return input | self()
 
     def __ror__(self, input):
         self.input = input
         return self
 
     def display(self):
         pass
 
 
 class iless(Display):
     cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
 
     def display(self):
         try:
             pager = os.popen(self.cmd, "w")
             try:
                 for item in xiter(self.input, "default"):
                     attrs = xattrs(item, "default")
                     attrs = ["%s=%s" % (a, _format(_getattr(item, a))) for a in attrs]
                     pager.write(" ".join(attrs))
                     pager.write("\n")
             finally:
                 pager.close()
         except Exception, exc:
             print "%s: %s" % (exc.__class__.__name__, str(exc))
 
 
 class idump(Display):
     def __init__(self, *attrs):
         self.attrs = attrs
         self.headerpadchar = " "
         self.headersepchar = "|"
         self.datapadchar = " "
         self.datasepchar = "|"
 
     def display(self):
         stream = sys.stdout
         if self.attrs:
             rows = []
             colwidths = dict([(a, len(_attrname(a))) for a in self.attrs])
 
             for item in xiter(self.input, "default"):
                 row = {}
                 for attrname in self.attrs:
                     value = _getattr(item, attrname, None)
                     text = _format(value)
                     colwidths[attrname] = max(colwidths[attrname], width)
                     row[attrname] = (value, text)
                 rows.append(row)
 
             for (i, attrname) in enumerate(self.attrs):
                 stream.write(_attrname(attrname))
                 spc = colwidths[attrname] - len(_attrname(attrname))
                 if i < len(colwidths)-1:
                     if spc>0:
                         stream.write(self.headerpadchar * spc)
                     stream.write(self.headersepchar)
             stream.write("\n")
 
             for row in rows:
                 for (i, attrname) in enumerate(self.attrs):
                     (value, text) = row[attrname]
                     spc = colwidths[attrname] - len(text)
                     if isinstance(value, (int, long)):
                         if spc>0:
                             stream.write(self.datapadchar*spc)
                         stream.write(text)
                     else:
                         stream.write(text)
                         if i < len(colwidths)-1:
                             if spc>0:
                                 stream.write(self.datapadchar*spc)
                     if i < len(colwidths)-1:
                         stream.write(self.datasepchar)
                 stream.write("\n")
         else:
             allattrs = []
             allattrset = set()
             colwidths = {}
             rows = []
             for item in xiter(self.input, "default"):
                 row = {}
                 attrs = xattrs(item, "default")
                 for attrname in attrs:
                     if attrname not in allattrset:
                         allattrs.append(attrname)
                         allattrset.add(attrname)
                         colwidths[attrname] = len(_attrname(attrname))
                     value = _getattr(item, attrname, None)
                     text = _format(value)
                     colwidths[attrname] = max(colwidths[attrname], len(text))
                     row[attrname] = (value, text)
                 rows.append(row)
 
             for (i, attrname) in enumerate(allattrs):
                 stream.write(_attrname(attrname))
                 spc = colwidths[attrname] - len(_attrname(attrname))
                 if i < len(colwidths)-1:
                     if spc>0:
                         stream.write(self.headerpadchar*spc)
                     stream.write(self.headersepchar)
             stream.write("\n")
 
             for row in rows:
                 for (i, attrname) in enumerate(attrs):
                     (value, text) = row.get(attrname, ("", ""))
                     spc = colwidths[attrname] - len(text)
                     if isinstance(value, (int, long)):
                         if spc>0:
                             stream.write(self.datapadchar*spc)
                         stream.write(text)
                     else:
                         stream.write(text)
                         if i < len(colwidths)-1:
                             if spc>0:
                                 stream.write(self.datapadchar*spc)
                     if i < len(colwidths)-1:
                         stream.write(self.datasepchar)
                 stream.write("\n")
 
 
 class XMode(object):
     def __init__(self, object, mode, title=None, description=None):
         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":
             return self.title
         return repr(self)
 
     def __xattrs__(self, mode):
         if mode == "detail":
             return ("object", "mode", "title", "description")
         return ("title", "description")
 
     def __xiter__(self, mode):
         return xiter(self.object, self.mode)
 
 
 class XAttr(object):
     def __init__(self, object, name):
         self.name = _attrname(name)
 
         try:
             self.value = _getattr(object, name)
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception, exc:
             if exc.__class__.__module__ == "exceptions":
                 self.value = exc.__class__.__name__
             else:
                 self.value = "%s.%s" % \
                     (exc.__class__.__module__, exc.__class__.__name__)
             self.type = self.value
         else:
             t = type(self.value)
             if t.__module__ == "__builtin__":
                 self.type = t.__name__
             else:
                 self.type = "%s.%s" % (t.__module__, t.__name__)
 
         doc = None
         if isinstance(name, basestring):
             try:
                 meta = getattr(type(object), name)
             except AttributeError:
                 pass
             else:
                 if isinstance(meta, property):
                     self.doc = getattr(meta, "__doc__", None)
         elif callable(name):
             try:
                 self.doc = name.__doc__
             except AttributeError:
                 pass
 
     def __xattrs__(self, mode):
         return ("name", "type", "doc", "value")
 
 
 _ibrowse_help = """
 down
 Move the cursor to the next line.
 
 up
 Move the cursor to the previous line.
 
 pagedown
 Move the cursor down one page (minus overlap).
 
 pageup
 Move the cursor up one page.
 
 left
 Move the cursor left.
 
 right
 Move the cursor right.
 
 home
 Move the cursor to the first column.
 
 end
 Move the cursor to the last column.
 
 pick
 'Pick' the object under the cursor (i.e. the row the cursor is on). This leaves
 the browser and returns the picked object to the caller. (In IPython this object
 will be available as the '_' variable.)
 
 pickattr
 'Pick' the attribute under the cursor (i.e. the row/column the cursor is on).
 
 pickallattrs
 Pick' the complete column under the cursor (i.e. the attribute under the cursor
 from all currently fetched objects). The attributes will be returned as a list.
 
 tooglemark
 Mark/unmark the object under the cursor. Marked objects have a '!' after the
 row number).
 
 pickmarked
 'Pick' marked objects. Marked objects will be returned as a list.
 
 pickmarkedattr
 'Pick' the attribute under the cursor from all marked objects (This returns a
 list)
 
 enterdefault
 Enter the object under the cursor. (what this mean depends on the object
 itself). This opens a new browser 'level'.
 
 enter
 Enter the object under the cursor. If the object provides different enter modes
 a menu of all modes will be presented, choice one and enter it (via the 'enter'
 or 'enterdefault' command),
 
 enterattr
 Enter the attribute under the cursor.
 
 leave
 Leave the current browser level and go back to the previous one.
 
 detail
 Show a detail view of the object under the cursor. This shows the name, type,
 doc string and value of the object attributes (and it might show more attributes
 than in the list view; depending on the object).
 
 markrange
 Mark all objects from the last marked object before the current cursor position
 to the cursor position.
 
 sortattrasc
 Sort the objects (in ascending order) using the attribute under the cursor as
 the sort key.
 
 sortattrdesc
 Sort the objects (in descending order) using the attribute under the cursor as
 the sort key.
 
 help
 This screen.
 """
 
 
 if curses is not None:
     class UnassignedKeyError(Exception):
         pass
 
 
     class UnknownCommandError(Exception):
         pass
 
 
     class CommandError(Exception):
         pass
 
 
     class Style(object):
         __slots__ = ("fg", "bg", "attrs")
 
         def __init__(self, fg, bg, attrs=0):
             self.fg = fg
             self.bg = bg
             self.attrs = attrs
 
 
     class _BrowserCachedItem(object):
         __slots__ = ("item", "marked")
 
         def __init__(self, item):
             self.item = item
             self.marked = False
 
 
     class _BrowserHelp(object):
         def __init__(self, browser):
             self.browser = browser
 
         def __xrepr__(self, mode):
             if mode == "header" or mode == "footer":
                 return "ibrowse help screen"
             return repr(self)
 
         def __xiter__(self, mode):
             # Get reverse key mapping
             allkeys = {}
             for (key, cmd) in self.browser.keymap.iteritems():
                 allkeys.setdefault(cmd, []).append(key)
 
             fields = ("key", "command", "description")
 
             for (i, command) in enumerate(_ibrowse_help.strip().split("\n\n")):
                 if i:
                     yield Fields(fields, key="", command="", description="")
 
                 (name, description) = command.split("\n", 1)
                 keys = allkeys.get(name, [])
                 lines = textwrap.wrap(description, 50)
 
                 for i in xrange(max(len(keys), len(lines))):
                     if i:
                         name = ""
                     try:
                         key = self.browser.keylabel(keys[i])
                     except IndexError:
                         key = ""
                     try:
                         line = lines[i]
                     except IndexError:
                         line = ""
                     yield Fields(fields, key=key, command=name, description=line)
 
 
     class _BrowserLevel(object):
         def __init__(self, browser, input, iterator, mainsizey, *attrs):
             self.browser = browser
             self.input = input
             self.header = xrepr(input, "header")
             self.iterator = iterator # iterator for the input
             self.exhausted = False # is the iterator exhausted?
             self.attrs = attrs
             self.items = deque()
             self.marked = 0 # Number of marked objects
             self.cury = 0 # Vertical cursor position
             self.curx = 0 # Horizontal cursor position
             self.datastarty = 0 # Index of first data line
             self.datastartx = 0 # Index of first data column
             self.mainsizey = mainsizey # height of the data display area
             self.mainsizex = 0 # width of the data display area
             self.numbersizex = 0 # Size of number at the left edge of the screen
             self.displayattrs = [] # Attribute names to display (in this order)
             self.displayattr = _default # Name of attribute under the cursor
             self.colwidths = {} # Maps attribute names to column widths
 
             self.fetch(mainsizey)
             self.calcdisplayattrs()
             # formatted attributes for the items on screen
             # (i.e. self.items[self.datastarty:self.datastarty+self.mainsizey])
             self.displayrows = [self.getrow(i) for i in xrange(len(self.items))]
             self.calcwidths()
             self.calcdisplayattr()
 
         def fetch(self, count):
             have = len(self.items)
             while not self.exhausted and have < count:
                 try:
                     item = self.iterator.next()
                 except StopIteration:
                     self.exhausted = True
                     break
                 else:
                     have += 1
                     self.items.append(_BrowserCachedItem(item))
 
         def calcdisplayattrs(self):
             attrnames = set()
             if self.attrs:
                 self.displayattrs = self.attrs
             else:
                 self.displayattrs = []
                 endy = min(self.datastarty+self.mainsizey, len(self.items))
                 for i in xrange(self.datastarty, endy):
                     for attrname in xattrs(self.items[i].item, "default"):
                         if attrname not in attrnames:
                             self.displayattrs.append(attrname)
                             attrnames.add(attrname)
 
         def getrow(self, i):
             row = {}
             item = self.items[i].item
             for attrname in self.displayattrs:
                 try:
                     value = _getattr(item, attrname, _default)
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     row[attrname] = self.browser.format(exc)
                 else:
                     # only store attribute if it exists
                     if value is not _default:
                         row[attrname] = self.browser.format(value)
             return row
 
         def calcwidths(self):
             # Recalculate the displayed fields and their width
             self.colwidths = {}
             for row in self.displayrows:
                 for attrname in self.displayattrs:
                     (align, text, style) = row.get(attrname, (2, "", None))
                     # always add attribute to colwidths, even if it doesn't exist
                     if attrname not in self.colwidths:
                         self.colwidths[attrname] = len(_attrname(attrname))
                     newwidth = max(self.colwidths[attrname], len(text))
                     self.colwidths[attrname] = newwidth
 
             # How many characters do we need to paint the item number?
             self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
             # How must space have we got to display data?
             self.mainsizex = self.browser.scrsizex-self.numbersizex-3
             # width of all columns
             self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
 
         def calcdisplayattr(self):
             # Find out on which attribute the cursor is on
             pos = 0
             for attrname in self.displayattrs:
                 if pos+self.colwidths[attrname] >= self.curx:
                     self.displayattr = attrname
                     break
                 pos += self.colwidths[attrname]+1
             else:
                 self.displayattr = None
 
         def moveto(self, x, y, refresh=False):
             olddatastarty = self.datastarty
             oldx = self.curx
             oldy = self.cury
             x = int(x+0.5)
             y = int(y+0.5)
 
             scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
             scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
 
             # Make sure that the cursor didn't leave the main area vertically
             if y < 0:
                 y = 0
             self.fetch(y+scrollbordery+1) # try to get more items
             if y >= len(self.items):
                 y = max(0, len(self.items)-1)
 
             # Make sure that the cursor stays on screen vertically
             if y < self.datastarty+scrollbordery:
                 self.datastarty = max(0, y-scrollbordery)
             elif y >= self.datastarty+self.mainsizey-scrollbordery:
                 self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
                                              len(self.items)-self.mainsizey))
 
             if refresh: # Do we need to refresh the complete display?
                 self.calcdisplayattrs()
                 endy = min(self.datastarty+self.mainsizey, len(self.items))
                 self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
                 self.calcwidths()
 
             # Did we scroll vertically => update displayrows
             # and various other attributes
             elif self.datastarty != olddatastarty:
                 # Recalculate which attributes we have to display
                 olddisplayattrs = self.displayattrs
                 self.calcdisplayattrs()
                 # If there are new attributes, recreate the cache
                 if self.displayattrs != olddisplayattrs:
                     endy = min(self.datastarty+self.mainsizey, len(self.items))
                     self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
                 elif self.datastarty<olddatastarty: # we did scroll up
                     # drop rows from the end
                     del self.displayrows[self.datastarty-olddatastarty:]
                     # fetch new items
                     for i in xrange(olddatastarty-1,
                                     self.datastarty-1, -1):
                         try:
                             row = self.getrow(i)
                         except IndexError:
                             # we didn't have enough objects to fill the screen
                             break
                         self.displayrows.insert(0, row)
                 else: # we did scroll down
                     # drop rows from the start
                     del self.displayrows[:self.datastarty-olddatastarty]
                     # fetch new items
                     for i in xrange(olddatastarty+self.mainsizey,
                                     self.datastarty+self.mainsizey):
                         try:
                             row = self.getrow(i)
                         except IndexError:
                             # we didn't have enough objects to fill the screen
                             break
                         self.displayrows.append(row)
                 self.calcwidths()
 
             # Make sure that the cursor didn't leave the data area horizontally
             if x < 0:
                 x = 0
             elif x >= self.datasizex:
                 x = max(0, self.datasizex-1)
 
             # Make sure that the cursor stays on screen horizontally
             if x < self.datastartx+scrollborderx:
                 self.datastartx = max(0, x-scrollborderx)
             elif x >= self.datastartx+self.mainsizex-scrollborderx:
                 self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
                                              self.datasizex-self.mainsizex))
 
             if x == oldx and y == oldy: # couldn't move
                 if self.browser._dobeep:
                     curses.beep()
                     # don't beep again (as long as the same key is pressed)
                     self.browser._dobeep = False
             else:
                 self.curx = x
                 self.cury = y
                 self.calcdisplayattr()
 
         def sort(self, key, reverse=False):
             """
             Sort the currently list of items using the key function ``key``. If
             ``reverse`` is true the sort order is reversed.
             """
             curitem = self.items[self.cury] # Remember where the cursor is now
 
             # Sort items
             def realkey(item):
                 return key(item.item)
             self.items = deque(sorted(self.items, key=realkey, reverse=reverse))
 
             # Find out where the object under the cursor went
             cury = self.cury
             for (i, item) in enumerate(self.items):
                 if item is curitem:
                     cury = i
                     break
 
             self.moveto(self.curx, cury, refresh=True)
 
 
     class ibrowse(Display):
         # Show this many lines from the previous screen when paging horizontally
         pageoverlapx = 1
 
         # Show this many lines from the previous screen when paging vertically
         pageoverlapy = 1
 
         # Start scrolling when the cursor is less than this number of columns
         # away from the left or right screen edge
         scrollborderx = 10
 
         # Start scrolling when the cursor is less than this number of lines
         # away from the top or bottom screen edge
         scrollbordery = 5
 
         # Accelerate by this factor when scrolling horizontally
         acceleratex = 1.05
 
         # Accelerate by this factor when scrolling vertically
         acceleratey = 1.05
 
         # The maximum horizontal scroll speed
         # (as a factor of the screen width (i.e. 0.5 == half a screen width)
         maxspeedx = 0.5
 
         # The maximum vertical scroll speed
         # (as a factor of the screen height (i.e. 0.5 == half a screen height)
         maxspeedy = 0.5
 
         # The maximum number of header lines for browser level
         # if the nesting is deeper, only the innermost levels are displayed
         maxheaders = 5
 
         # Styles for various parts of the GUI
         style_objheadertext = Style(curses.COLOR_WHITE, curses.COLOR_BLACK, curses.A_BOLD|curses.A_REVERSE)
         style_objheadernumber = Style(curses.COLOR_WHITE, curses.COLOR_BLUE, curses.A_BOLD|curses.A_REVERSE)
         style_objheaderobject = Style(curses.COLOR_WHITE, curses.COLOR_BLACK, curses.A_REVERSE)
         style_colheader = Style(curses.COLOR_BLUE, curses.COLOR_WHITE, curses.A_REVERSE)
         style_colheaderhere = Style(curses.COLOR_GREEN, curses.COLOR_BLACK, curses.A_BOLD|curses.A_REVERSE)
         style_colheadersep = Style(curses.COLOR_BLUE, curses.COLOR_BLACK, curses.A_REVERSE)
         style_number = Style(curses.COLOR_BLUE, curses.COLOR_WHITE, curses.A_REVERSE)
         style_numberhere = Style(curses.COLOR_GREEN, curses.COLOR_BLACK, curses.A_BOLD|curses.A_REVERSE)
         style_sep = Style(curses.COLOR_BLUE, curses.COLOR_BLACK)
         style_data = Style(curses.COLOR_WHITE, curses.COLOR_BLACK)
         style_datapad = Style(curses.COLOR_BLUE, curses.COLOR_BLACK, curses.A_BOLD)
         style_footer = Style(curses.COLOR_BLACK, curses.COLOR_WHITE)
         style_noattr = Style(curses.COLOR_RED, curses.COLOR_BLACK)
         style_error = Style(curses.COLOR_RED, curses.COLOR_BLACK)
         style_default = Style(curses.COLOR_WHITE, curses.COLOR_BLACK)
         style_report = Style(curses.COLOR_WHITE, curses.COLOR_BLACK)
 
         # Styles for datatypes
         style_type_none = Style(curses.COLOR_MAGENTA, curses.COLOR_BLACK)
         style_type_bool = Style(curses.COLOR_GREEN, curses.COLOR_BLACK)
         style_type_number = Style(curses.COLOR_YELLOW, curses.COLOR_BLACK)
         style_type_datetime = Style(curses.COLOR_CYAN, curses.COLOR_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 = "-"
 
         # Maps curses key codes to "function" names
         keymap = {
             ord("q"): "quit",
             curses.KEY_UP: "up",
             curses.KEY_DOWN: "down",
             curses.KEY_PPAGE: "pageup",
             curses.KEY_NPAGE: "pagedown",
             curses.KEY_LEFT: "left",
             curses.KEY_RIGHT: "right",
             curses.KEY_HOME: "home",
             curses.KEY_END: "end",
             ord("p"): "pick",
             ord("P"): "pickattr",
             ord("C"): "pickallattrs",
             ord("m"): "pickmarked",
             ord("M"): "pickmarkedattr",
             ord("\n"): "enterdefault",
             # FIXME: What's happening here?
             8: "leave",
             127: "leave",
             curses.KEY_BACKSPACE: "leave",
             ord("x"): "leave",
             ord("h"): "help",
             ord("e"): "enter",
             ord("E"): "enterattr",
             ord("d"): "detail",
             ord(" "): "tooglemark",
             ord("r"): "markrange",
             ord("v"): "sortattrasc",
             ord("V"): "sortattrdesc",
         }
 
         def __init__(self, *attrs):
             self.attrs = attrs
             self.levels = []
             self.stepx = 1. # how many colums to scroll
             self.stepy = 1. # how many rows to scroll
             self._dobeep = True # Beep on the edges of the data area?
             self._colors = {}
             self._maxcolor = 1
             self._headerlines = 1 # How many header lines do we want to paint (the numbers of levels we have, but with an upper bound)
             self._firstheaderline = 0 # Index of first header line
             self.scr = None # curses window
             self._report = None # report in the footer line
 
         def nextstepx(self, step):
             return max(1., min(step*self.acceleratex,
                                self.maxspeedx*self.levels[-1].mainsizex))
 
         def nextstepy(self, step):
             return max(1., min(step*self.acceleratey,
                                self.maxspeedy*self.levels[-1].mainsizey))
 
         def getstyle(self, style):
             try:
                 return self._colors[style.fg, style.bg] | style.attrs
             except KeyError:
                 curses.init_pair(self._maxcolor, style.fg, style.bg)
                 pair = curses.color_pair(self._maxcolor)
                 self._colors[style.fg, style.bg] = pair
                 c = pair | style.attrs
                 self._maxcolor += 1
                 return c
 
         def addstr(self, y, x, begx, endx, s, style):
             s2 = s[max(0, begx-x):max(0, endx-x)]
             if s2:
                 self.scr.addstr(y, max(x, begx), s2, self.getstyle(style))
             return len(s)
 
         def format(self, value):
             if value is None:
                 return (-1, repr(value), self.style_type_none)
             elif isinstance(value, str):
                 return (-1, repr(value.expandtabs(tab))[1:-1], self.style_default)
             elif isinstance(value, unicode):
                 return (-1, repr(value.expandtabs(tab))[2:-1], self.style_default)
             elif isinstance(value, datetime.datetime):
                 # Don't use strftime() here, as this requires year >= 1900
                 return (-1, "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
                             (value.year, value.month, value.day,
                              value.hour, value.minute, value.second,
                              value.microsecond),
                         self.style_type_datetime)
             elif isinstance(value, datetime.date):
                 return (-1, "%04d-%02d-%02d" % \
                             (value.year, value.month, value.day),
                         self.style_type_datetime)
             elif isinstance(value, datetime.time):
                 return (-1, "%02d:%02d:%02d.%06d" % \
                             (value.hour, value.minute, value.second,
                              value.microsecond),
                         self.style_type_datetime)
             elif isinstance(value, datetime.timedelta):
                 return (-1, repr(value), self.style_type_datetime)
             elif isinstance(value, bool):
                 return (-1, repr(value), self.style_type_bool)
             elif isinstance(value, (int, long, float)):
                 return (1, repr(value), self.style_type_number)
             elif isinstance(value, complex):
                 return (-1, repr(value), self.style_type_number)
             elif isinstance(value, Exception):
                 if value.__class__.__module__ == "exceptions":
                     value = "%s: %s" % (value.__class__.__name__, value)
                 else:
                     value = "%s.%s: %s" % \
                         (value.__class__.__module__, value.__class__.__name__,
                          value)
                 return (-1, value, self.style_error)
             return (-1, repr(value), self.style_default)
 
         def _calcheaderlines(self, 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 Style(style.fg, style.bg, style.attrs | curses.A_BOLD)
 
         def report(self, msg):
             self._report = msg
 
         def enter(self, item, mode, *attrs):
             try:
                 iterator = xiter(item, mode)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception, exc:
                 curses.beep()
                 self.report(exc)
             else:
                 self._calcheaderlines(len(self.levels)+1)
                 level = _BrowserLevel(
                     self,
                     item,
                     iterator,
                     self.scrsizey-1-self._headerlines-2,
                     *attrs
                 )
                 self.levels.append(level)
 
         def keylabel(self, keycode):
             if keycode <= 0xff:
                 specialsnames = {
                     ord("\n"): "RETURN",
                     ord(" "): "SPACE",
                     ord("\t"): "TAB",
                     ord("\x7f"): "DELETE",
                     ord("\x08"): "BACKSPACE",
                 }
                 if keycode in specialsnames:
                     return specialsnames[keycode]
                 return repr(chr(keycode))
             for name in dir(curses):
                 if name.startswith("KEY_") and getattr(curses, name) == keycode:
                     return name
             return str(keycode)
 
         def cmd_help(self):
             for level in self.levels:
                 if isinstance(level.input, _BrowserHelp):
                     curses.beep()
                     self.report(CommandError("help already active"))
                     return
 
             self.enter(_BrowserHelp(self), "default")
 
         def _dodisplay(self, scr):
             self.scr = scr
             curses.halfdelay(1)
             footery = 2
 
             keys = []
             for (key, cmd) in self.keymap.iteritems():
                 if cmd == "quit":
                     keys.append("%s=%s" % (self.keylabel(key), cmd))
             for (key, cmd) in self.keymap.iteritems():
                 if cmd == "help":
                     keys.append("%s=%s" % (self.keylabel(key), cmd))
             helpmsg = " %s" % " ".join(keys)
 
             scr.clear()
             msg = "Fetching first batch of objects..."
             (self.scrsizey, self.scrsizex) = scr.getmaxyx()
             scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
             scr.refresh()
 
             lastc = -1
 
             self.levels = []
             # enter the first level
             self.enter(self.input, xiter(self.input, "default"), *self.attrs)
 
             self._calcheaderlines(None)
 
             while True:
                 level = self.levels[-1]
                 (self.scrsizey, self.scrsizex) = scr.getmaxyx()
                 level.mainsizey = self.scrsizey-1-self._headerlines-footery
 
                 # Paint object header
                 for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
                     lv = self.levels[i]
                     posx = 0
                     posx += self.addstr(i-self._firstheaderline, posx, 0, self.scrsizex, " ibrowse #%d: " % i, self.style_objheadertext)
                     posx += self.addstr(i-self._firstheaderline, posx, 0, self.scrsizex, lv.header, self.style_objheaderobject)
                     if i: # not the first level
                         posx += self.addstr(i-self._firstheaderline, posx, 0, self.scrsizex, " == ", self.style_objheadertext)
                         msg = "%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
                         if not self.levels[i-1].exhausted:
                             msg += "+"
                         posx += self.addstr(i-self._firstheaderline, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
                     if posx < self.scrsizex:
                         scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_objheadertext))
 
                 # Paint column headers
                 scr.move(self._headerlines, 0)
                 scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
                 scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
                 begx = level.numbersizex+3
                 posx = begx-level.datastartx
                 for attrname in level.displayattrs:
                     strattrname = _attrname(attrname)
                     cwidth = level.colwidths[attrname]
                     header = strattrname.ljust(cwidth)
                     if attrname == level.displayattr:
                         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]
                         (align, text, style) = level.displayrows[i-level.datastarty].get(attrname, (2, None, self.style_noattr))
                         padstyle = self.style_datapad
                         sepstyle = self.style_sep
                         if i == level.cury:
                             style = self.getstylehere(style)
                             padstyle = self.getstylehere(padstyle)
                             sepstyle = self.getstylehere(sepstyle)
                         if align == 2:
                             text = self.nodatachar*cwidth
                             posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
                         elif align == -1:
                             pad = self.datapadchar*(cwidth-len(text))
                             posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
                             posx += self.addstr(posy, posx, begx, self.scrsizex, pad, padstyle)
                         elif align == 0:
                             pad1 = self.datapadchar*((cwidth-len(text))//2)
                             pad2 = self.datapadchar*(cwidth-len(text)-len(pad1))
                             posx += self.addstr(posy, posx, begx, self.scrsizex, pad1, padstyle)
                             posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
                             posx += self.addstr(posy, posx, begx, self.scrsizex, pad2, padstyle)
                         elif align == 1:
                             pad = self.datapadchar*(cwidth-len(text))
                             posx += self.addstr(posy, posx, begx, self.scrsizex, pad, padstyle)
                             posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
                         posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
                         if posx >= self.scrsizex:
                             break
                     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()
 
                 # Display footer
                 scr.addstr(self.scrsizey-footery, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
 
                 if level.exhausted:
                     flag = ""
                 else:
                     flag = "+"
 
                 scr.addstr(self.scrsizey-footery, self.scrsizex-len(helpmsg)-1, helpmsg, self.getstyle(self.style_footer))
 
                 msg = "%d%s objects (%d marked)" % (len(level.items), flag, level.marked)
                 try:
                     msg += ": %s > %s" % (xrepr(level.items[level.cury].item, "footer"), _attrname(level.displayattr))
                 except IndexError: # empty
                     pass
                 self.addstr(self.scrsizey-footery, 1, 1, self.scrsizex-len(helpmsg)-1, msg, self.style_footer)
 
                 # Display report
                 if self._report is not None:
                     if isinstance(self._report, Exception):
                         style = self.getstyle(self.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
                     try:
                         scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
                     except curses.err:
                         # Protect against error from writing to the last line
                         pass
                     self._report = None
                 else:
                     scr.move(self.scrsizey-1, 0)
                 scr.clrtoeol()
 
                 # Position cursor
                 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 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
                         cmd = self.keymap.get(c, None)
                         if cmd == "quit":
                             return
                         elif cmd == "up":
                             self.report("up")
                             level.moveto(level.curx, level.cury-self.stepy)
                         elif cmd == "down":
                             self.report("down")
                             level.moveto(level.curx, level.cury+self.stepy)
                         elif cmd == "pageup":
                             self.report("page up")
                             level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
                         elif cmd == "pagedown":
                             self.report("page down")
                             level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
                         elif cmd == "left":
                             self.report("left")
                             level.moveto(level.curx-self.stepx, level.cury)
                         elif cmd == "right":
                             self.report("right")
                             level.moveto(level.curx+self.stepx, level.cury)
                         elif cmd == "home":
                             self.report("home")
                             level.moveto(0, level.cury)
                         elif cmd == "end":
                             self.report("end")
                             level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
                         elif cmd == "pick":
                             return level.items[level.cury].item
                         elif cmd == "pickattr":
                             attr = _getattr(level.items[level.cury].item, level.displayattr)
                             if attr is _default:
                                 curses.beep()
                                 self.report(AttributeError(_attrname(level.displayattr)))
                             else:
                                 return attr
                         elif cmd == "pickallattrs":
                             result = []
                             for cache in level.items:
                                 attr = _getattr(cache.item, level.displayattr)
                                 if attr is not _default:
                                     result.append(attr)
                             return result
                         elif cmd == "pickmarked":
                             return [cache.item for cache in level.items if cache.marked]
                         elif cmd == "pickmarkedattr":
                             result = []
                             for cache in level.items:
                                 if cache.marked:
                                     attr = _getattr(cache.item, level.displayattr)
                                     if attr is not _default:
                                         result.append(attr)
                             return result
                         elif cmd == "markrange":
                             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
                         elif cmd == "enterdefault":
                             self.report("entering object (default mode)...")
                             self.enter(level.items[level.cury].item, "default")
                         elif cmd == "leave":
                             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()
                         elif cmd == "enter":
                             self.report("entering object...")
                             self.enter(level.items[level.cury].item, None)
                         elif cmd == "enterattr":
                             self.report("entering object attribute %s..." % _attrname(level.displayattr))
                             self.enter(_getattr(level.items[level.cury].item, level.displayattr), None)
                         elif cmd == "detail":
                             self.enter(level.items[level.cury].item, "detail")
                         elif cmd == "tooglemark":
                             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
                         elif cmd == "sortattrasc":
                             self.report("sort by %s (ascending)" % _attrname(level.displayattr))
                             def key(item):
                                 return _getattr(item, level.displayattr)
                             level.sort(key)
                         elif cmd == "sortattrdesc":
                             self.report("sort by %s (descending)" % _attrname(level.displayattr))
                             def key(item):
                                 return _getattr(item, level.displayattr)
                             level.sort(key, reverse=True)
                         elif cmd == "help":
                             self.cmd_help()
                         elif cmd is not None:
                             self.report(UnknownCommandError("Unknown command %r" % (cmd,)))
                         else:
                             self.report(UnassignedKeyError("Unassigned key %s" % self.keylabel(c)))
                         self.stepx = self.nextstepx(self.stepx)
                         self.stepy = self.nextstepy(self.stepy)
                         curses.flushinp() # get rid of type ahead
                         break # Redisplay
             self.scr = None
 
         def display(self):
             return curses.wrapper(self._dodisplay)
 
     defaultdisplay = ibrowse
     __all__.append("ibrowse")
 else:
     defaultdisplay = idump
 
 
 # If we're running under IPython, install an IPython displayhook that
 # returns the object from Display.display(), else install a displayhook
 # directly as sys.displayhook
 try:
     from IPython import ipapi
     api = ipapi.get()
 except (ImportError, AttributeError):
     api = None
 
 if api is not None:
     def displayhook(self, obj):
         if isinstance(obj, type) and issubclass(obj, Table):
             obj = obj()
         if isinstance(obj, Table):
             obj = obj | defaultdisplay
         if isinstance(obj, Display):
             return obj.display()
         else:
             raise ipapi.TryNext
     api.set_hook("result_display", displayhook)
 else:
     def installdisplayhook():
         _originalhook = sys.displayhook
         def displayhook(obj):
             if isinstance(obj, type) and issubclass(obj, Table):
                 obj = obj()
             if isinstance(obj, Table):
                 obj = obj | defaultdisplay
             if isinstance(obj, Display):
                 return obj.display()
             else:
                 _originalhook(obj)
         sys.displayhook = displayhook
     installdisplayhook()