예제 #1
0
 def test_lazycache_provide_after_failed_lookup(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     linecache.clearcache()
     linecache.getlines(NONEXISTENT_FILENAME)
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     self.assertEqual(lines, linecache.updatecache(NONEXISTENT_FILENAME))
 def test_basics(self):
     linecache.clearcache()
     linecache.lazycache("f", globals())
     f = traceback.FrameSummary("f", 1, "dummy")
     self.assertEqual(
         ("f", 1, "dummy", '"""Test cases for traceback module"""'),
         tuple(f))
     self.assertEqual(None, f.locals)
 def test_lazy_lines(self):
     linecache.clearcache()
     f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False)
     self.assertEqual(None, f._line)
     linecache.lazycache("f", globals())
     self.assertEqual(
         '"""Test cases for traceback module"""',
         f.line)
예제 #4
0
 def test_basics(self):
     linecache.clearcache()
     linecache.lazycache("f", globals())
     f = traceback.FrameSummary("f", 1, "dummy")
     self.assertEqual(f,
         ("f", 1, "dummy", '"""Test cases for traceback module"""'))
     self.assertEqual(tuple(f),
         ("f", 1, "dummy", '"""Test cases for traceback module"""'))
     self.assertEqual(f, traceback.FrameSummary("f", 1, "dummy"))
     self.assertEqual(f, tuple(f))
     # Since tuple.__eq__ doesn't support FrameSummary, the equality
     # operator fallbacks to FrameSummary.__eq__.
     self.assertEqual(tuple(f), f)
     self.assertIsNone(f.locals)
예제 #5
0
파일: debuggers.py 프로젝트: jalanb/dotsite
def stack_sources():
    """A list of sources for frames above this"""
    # lazy imports
    import linecache
    result = []
    for frame_info in reversed(inspect.stack()):
        _frame, filename, line_number, _function, _context, _index = frame_info
        linecache.lazycache(filename, {})
        _line = linecache.getline(filename, line_number).rstrip()

    # Each record contains a frame object, filename, line number, function
    # name, a list of lines of context, and index within the context
    _sources = [(path, line) for _, path, line, _, _, _ in inspect.stack()]
    return result
예제 #6
0
 def test_lazycache_already_cached(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     self.assertEqual(
         False,
         linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(4, len(linecache.cache[NONEXISTENT_FILENAME]))
예제 #7
0
    def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
            capture_locals=False):
        """Create a StackSummary from a traceback or stack object.

        :param frame_gen: A generator that yields (frame, lineno) tuples to
            include in the stack.
        :param limit: None to include all frames or the number of frames to
            include.
        :param lookup_lines: If True, lookup lines for each frame immediately,
            otherwise lookup is deferred until the frame is rendered.
        :param capture_locals: If True, the local variables from each frame will
            be captured as object representations into the FrameSummary.
        """
        if limit is None:
            limit = getattr(sys, 'tracebacklimit', None)
            if limit is not None and limit < 0:
                limit = 0
        if limit is not None:
            if limit >= 0:
                frame_gen = itertools.islice(frame_gen, limit)
            else:
                frame_gen = collections.deque(frame_gen, maxlen=-limit)

        result = klass()
        fnames = set()
        for f, lineno in frame_gen:
            co = f.f_code
            filename = co.co_filename
            name = co.co_name

            fnames.add(filename)
            linecache.lazycache(filename, f.f_globals)
            # Must defer line lookups until we have called checkcache.
            if capture_locals:
                f_locals = f.f_locals
            else:
                f_locals = None
            result.append(FrameSummary(
                filename, lineno, name, lookup_line=False, locals=f_locals))
        for filename in fnames:
            linecache.checkcache(filename)
        # If immediate lookup was desired, trigger lookups now.
        if lookup_lines:
            for f in result:
                f.line
        return result
예제 #8
0
 def test_lazycache_smoke(self):
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     linecache.clearcache()
     self.assertEqual(
         True, linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(1, len(linecache.cache[NONEXISTENT_FILENAME]))
     # Note here that we're looking up a non existant filename with no
     # globals: this would error if the lazy value wasn't resolved.
     self.assertEqual(lines, linecache.getlines(NONEXISTENT_FILENAME))
예제 #9
0
 def test_lazycache_bad_filename(self):
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache('', globals()))
     self.assertEqual(False, linecache.lazycache('<foo>', globals()))
예제 #10
0
 def test_lazycache_check(self):
     linecache.clearcache()
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     linecache.checkcache()
 def test_lazycache_no_globals(self):
     lines = linecache.getlines(FILENAME)
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache(FILENAME, None))
     self.assertEqual(lines, linecache.getlines(FILENAME))
예제 #12
0
 def test_lazy_lines(self):
     linecache.clearcache()
     f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False)
     self.assertEqual(None, f._line)
     linecache.lazycache("f", globals())
     self.assertEqual('"""Test cases for traceback module"""', f.line)
예제 #13
0
 def test_lazycache_no_globals(self):
     lines = linecache.getlines(FILENAME)
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache(FILENAME, None))
     self.assertEqual(lines, linecache.getlines(FILENAME))
예제 #14
0
파일: nodes.py 프로젝트: xxoolm/Ryven
 def update_event(self, inp=-1):
     self.set_output_val(0, linecache.lazycache(self.input(0), self.input(1)))
 def test_lazycache_check(self):
     linecache.clearcache()
     linecache.lazycache(NONEXISTENT_FILENAME, globals())
     linecache.checkcache()
예제 #16
0
 def lazycache(cls, frame):
     if hasattr(linecache, 'lazycache'):
         linecache.lazycache(frame.f_code.co_filename, frame.f_globals)
 def test_lazycache_already_cached(self):
     linecache.clearcache()
     lines = linecache.getlines(NONEXISTENT_FILENAME, globals())
     self.assertEqual(False,
                      linecache.lazycache(NONEXISTENT_FILENAME, globals()))
     self.assertEqual(4, len(linecache.cache[NONEXISTENT_FILENAME]))
 def test_lazycache_bad_filename(self):
     linecache.clearcache()
     self.assertEqual(False, linecache.lazycache('', globals()))
     self.assertEqual(False, linecache.lazycache('<foo>', globals()))