class Traceback(list):

def __init__(self, tb):

    """ initialize from given python traceback object. """

    if hasattr(tb, 'tb_next'):

        def f(cur): 

            while cur is not None: 

                yield self.Entry(cur)

                cur = cur.tb_next 

        list.__init__(self, f(tb)) 

    else:

        list.__init__(self, tb)

def cut(self, path=None, lineno=None, firstlineno=None):

    """ return a Traceback instance wrapping part of this Traceback

            by provding any combination of path, lineno and firstlineno, the

            first frame to start the to-be-returned traceback is determined

            this allows cutting the first part of a Traceback instance e.g.

            for formatting reasons (removing some uninteresting bits that deal

            with handling of the exception/traceback)

        """

    for x in self:

        if ((path is None or x.frame.code.path == path) and

            (lineno is None or x.lineno == lineno) and

            (firstlineno is None or x.frame.code.firstlineno == firstlineno)):

            return Traceback(x._rawentry)

    return self

def filter(self, fn=lambda x: not x.ishidden()):

    """ return a Traceback instance with certain items removed

            fn is a function that gets a single argument, a TracebackItem

            instance, and should return True when the item should be added

            to the Traceback, False when not

            by default this removes all the TracebackItems which are hidden

            (see ishidden() above)

        """

    return Traceback(filter(fn, self))

def getcrashentry(self):

    """ return last non-hidden traceback entry that lead

        to the exception of a traceback. 

        """

    tb = self.filter()

    if not tb:

        tb = self

    return tb[-1]

def recursionindex(self):

    """ return the index of the frame/TracebackItem where recursion

            originates if appropriate, None if no recursion occurred

        """

    cache = {}

    for i, entry in py.builtin.enumerate(self):

        key = entry.frame.code.path, entry.lineno 

        #print "checking for recursion at", key

        l = cache.setdefault(key, [])

        if l: 

            f = entry.frame

            loc = f.f_locals

            for otherloc in l: 

                if f.is_true(f.eval(co_equal, 

                    __recursioncache_locals_1=loc,

                    __recursioncache_locals_2=otherloc)):

                    return i 

        l.append(entry.frame.f_locals)

    return None

def __getitem__(self, key):

    val = super(Traceback, self).__getitem__(key)

    if isinstance(key, type(slice(0))):

        val = self.__class__(val)

    return val